diff --git a/.gitignore b/.gitignore
index feee3a44..2df0e95b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,6 @@
 public
-build
\ No newline at end of file
+./build
+node_modules
+resources
+npm-debug.log
+.hugo_build.lock
\ No newline at end of file
diff --git a/.gitmodules b/.gitmodules
index 6433a7d0..f1734c10 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,3 +1,3 @@
-[submodule "themes/learn"]
-	path = themes/learn
-	url = https://github.com/matcornic/hugo-theme-learn.git
+[submodule "static/playground"]
+	path = static/playground
+	url = https://github.com/tinygo-org/playground.git
diff --git a/README.md b/README.md
index 729fcf6e..ab96319a 100644
--- a/README.md
+++ b/README.md
@@ -8,13 +8,17 @@ Built using Hugo:
 
 http://gohugo.io/
 
-and the Hugo "Learn" theme:
+and the Hugo "Docsy" theme:
 
-https://github.com/matcornic/hugo-theme-learn
+https://github.com/google/docsy
 
-## Installation
+## Prerequisites
+
+Install Hugo command line tool for your operating system with the "extended" option, along with the needed NodeJS modules for processing the site CSS:
+
+https://www.docsy.dev/docs/getting-started/#prerequisites-and-installation
 
-Install Hugo command line tool for your operating system.
+## Installation
 
 Clone this repo using:
 
@@ -24,11 +28,7 @@ Change directories into the tinygo-site directory:
 
     cd tinygo-site
 
-Install the "Learn" theme:
-
-    git submodule update --init
-
-Now you should be able to run the site locally:
+You are now able to run the site locally, "Docsy" theme will be automatically downloaded as module:
 
     hugo serve
 
@@ -42,7 +42,4 @@ That's it.
 
 ## TODO:
 
-- Generate custom godocs for all tinygo build tags, add to "Documentation" section, and point Godocs links there.
-- Activate search.
-- Custom domain for all packages
 - ?
diff --git a/assets/icons/logo.svg b/assets/icons/logo.svg
new file mode 100644
index 00000000..87d192e7
--- /dev/null
+++ b/assets/icons/logo.svg
@@ -0,0 +1,110 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="60px" height="51px" viewBox="0 0 60 51" enable-background="new 0 0 60 51" xml:space="preserve">  <image id="image0" width="60" height="51" x="0" y="0"
+    href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADwAAAAzCAYAAADLqmunAAAABGdBTUEAALGPC/xhBQAAACBjSFJN
+AAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAABmJLR0QA/wD/AP+gvaeTAAAA
+CXBIWXMAABTqAAAU6gFxlYZXAAAAB3RJTUUH5QUEDAo1aJntewAAFoVJREFUaN61emlwW9eV5vf2
+DQ/7QkIUQRDcRImULEVyRNqOVPESx7HkLMrIXeks1enqdieVlLsm+THzI5XqznRN1cxUT9LpTKZS
+cdp2u2O7rZTkKkujyIss2RZlS5ZEiaS4QBBIilgIkNgeH/Dw3p0fJGiCi2Spu49KBRR437nfd+65
+555z7qOwsShut/s/OxyO77As6wdAAyC4e6Eymcwfs9nsVwFUNhgjuN3u1zwez8P3OgcAq1qtpnK5
+3G+z2ez/BFBabyBb++L3+xGJRLBlyxaEQiH89Kc/fcDj8fzYbrfL9wBgtfTpun5Q07RX7XY7FhYW
+QFEURFFEPp+HLMsHPB5Pn91uF/6N84RYlv3x/Pz8uZ/85Ccnp6amcO3aNUSjUSQSCQAAc+bMGTz3
+3HOwLMvu9/sjDMM8WCwWP0cI+RJN07tYdtEmhJB7/s9xnMTz/OdomvaWSiXdMAyYpum0LKvH5XL9
+lc/n+682m817r/MAAEVRNZx8Q0MDxfN8IJfLNRcKBWZqaqpcqVQqp0+fBnXgwIH/HgqFvIqidNts
+thZJkjyCIHCDg4N47733IAgCLMsCTdNwOByQJOmezW+aJgzDyBNCsgBA07SbZVk7wzD3rHNhYQG5
+XG4ZY7lcRn9/P3p6elCpVAxN07LFYvFmoVC4dvPmzTTb1tb2487OzpUWAk3TqK2sZVnw+/148skn
+0dbWBkG4d6+jKAqEEDsA+6rf7llnuVzG+Pg4Xn/9daRSKQAAy7IQBAEcx3E2my3g9/sDhJA9giCA
+TSQSb8uy7JBluVkURZcgCAzHcXUgDx48iL6+Ppim+W8C9x8hdrsdDQ0NoGkav/nNb5Z/J4SgWq2i
+UqmYCwsL85qmTSYSiTn2pZdeetzj8UidnZ2bfD5ft8Ph2C3LcnB4eLiNEHI/x3Hw+/2wLOuuyRJC
+lj1n9efKMas/V4+50xw1L+Q4DuVyGVevXh0wTXNc1/VbuVzuQiqVGhoeHp7KZrMa63A4lGAwqDgc
+Do+iKH5FUTyyLPskSVJXg1oJiAJQNc0616+5J0VRoCgKNE2jWq2iXNaxoC2gpJWgaRoMwwAAcBwH
+SRQhKzbYFAWiKIJhmLqAtFpnzRi1BVi5FWsiSZKqKIqPpulKtVr1qarqCQaDOcuywB44cOBUW1ub
+Q5KkgCiKCsdxYFkW5XIZU1NT665YPp/H2++8g9TsLLxuNx7o74ff7wchBAzDQNM0TE9NYSI6gVuJ
+JIoLZZgWwPAiOF4ERdOL+iwTVaMC0yiDgQWHTcbmpk2ItEbQ0NgInueXDQkAk5NxRKM3IIkiurdu
+haIoa7yOoii0tbV1d3V1dVerVRiG8R1d17WFhYXkxMTEHOvxeO7z+/2gafqOAaQ28ZtvvYW8JaLn
+cwcxHRvHy6/9AYe/9mXwPI8LFy5geGwChJXgbwqj9TPbYHe6IUoyWI4HwzBAzWWX3LFqVKCVipib
+TWJ68gYuHz8FmQW292zFtm09kGUZZ86cwcDHg2gMd6I4NY2R0TF8/dDXbhtEaZqGKIoQBEFWVTU8
+NzcXZoeGhn5QKpUaVVXtUVW1Q1GUgCAIgq7rDAButZJyWcetRAo7H/4KnG4vzKoBYln47XPPQbI5
+4Ghowa6HvwqvvxEsx4GQmruRZZKffF8ExQsieEGCy+tHpKsH5bKOxGQMH186j4uXrqAx4MP12DQe
++OLXUa2U0bg5jD8eeR6Tk3F0dHSuIarruqFpmlkulyulUilZKBTG8/n85Xg8PsN6PJ5fPPHEE3jq
+qae4QCDQ0tHRsdfhcLTHYrH7LMt6Yq3VGLAsg2wqgYmhS5iMjkFSFLCqH3sf/wr8wc0AITBNc80+
+W3KTFd/rNgyIRWARAo7jEWrrQnOkC7fiUbx74ggYhsf8bArTN8ehOt3gBAHVanUNWcuycO7cuZOJ
+ROLjQqEwPjY2du7WrVs33njjjcoLL7wARlXVR+PxeH9/f/839uzZ8+0tW7Y8FYlE+miabksmkwLP
+8+jr64Pb7QYhBCzLIpNJIz49g7buHbh28X2UigV0bd+FbCqBWzfHUcjNg+N5CJIM6i4i78rgVMjP
+49bNKPJzGTjcXkzfjOL86f8Hu8sNEILsdBT9n90DQRBBURTm5ubw/vvvo1qt4r777mvcvXv39ubm
+5vu7urr2dnd3bx8YGGiIx+MBdteuXa93dHSwLMvSDMMsR1en07khqL2f3YvRF1/E2ZNHYZVL2NLV
+hQbRhMvlBEBhJjGJc4MfwObdjB19+6HY1Lrgs5FemqZRLORw6YN3kJ2Owu92oKEhAL8qw7ajG4O0
+gXIpj4nhK+htC8Hlcq8bcxwOh+rxeFTLsvyEkDbTNB+pVqtkdHTUYCuVSrZcLiuEEBsA6nZpXg2U
+ZVlgQNCx2YdDf/09tLe3o1AoAACCwSAAIJlM4OjRo3jn2Et44PGvweHybEi6pjeTSuDs8Vexra0Z
+f/bD76M1EoFhGEin0wgGgyCEYHDwCl544QVoWgmGYSwfixvhXUpnUalUipVKpcTouv5GOp0+Mjc3
+N5DL5eLakkSj0ers7Ky60qVrQeu1115DT08PvvvdP0drays+uvAR/umF5/Hz//33aGrajNbWVths
+Ntx3306YZQ3vvH0KzW3dYDYAR1EUFkpFnH79X/D5/t14+uk/QXMohMnJSZx5/wP83d/9DPF4DPv2
+7UcoFMKDDz6IK1cuY2JiApFIBDRNL7t0pVKBKIozoihOptPpoampqePj4+O/HRwc/PuhoaFfsd//
+/veHn3nmGfA8P9zb23s5EAjcb7PZwrFYrIcQ0rga2MDAAJxOJ5566svweDzQNA3PP/88CEVjYmIC
+Z8+ewcMPP7wU4GgcPHgQE9EoRi5/hN77H4RlmmtWmaIoXD7/LraEN+ELX3gcTqcTFEXh2LGjeO0P
+f0AyMYOqYaBUKsHpdMJut+Mv//IZ/Oxnf4vx8TF0dW2pW9VYLHaVZdmrmqbFUqnUwODg4Limadlf
+//rXhD158uQ/Pvvss15FUboURWmSJMkhCALtcrlw9uzZOmDFYhGjo6P4xjf+FG63e/FI4XkIPIdX
+XnkFHMehtbW17hmWZXHwwJP4H//wf9G1/TPg+LXnZiE/j8zUBA5/9ztwOByglxKTcDiM2WQClXIZ
+/f19sNlsK/cpDhw4iGPHjqK9vWP5d5qmsXv37ke2b9/+SKVSsRYWFvKPPvrodKFQGDlx4kSKDYfD
+z6xXLa3eyzRNY3JyEk6nEy0tLeB5HgDA8zyeffav4XS6oKoqvvSlJ9cQCodb4bHLyKSTaGwK1QUa
+iqaRmIwh6HNjU1PTsl4A+OIXn4DP50c+n8fevXvX7NcdO3bg6NE/IJvN1nkNwzBgWRY0TdOSJDnd
+breTELKVpmmwk5OTR3med8uyHJZl2ScIgrBy0pWSSMygqakJsizXTdDaGsHf/M3fbhg8eJ7H5mAj
+5jIpBDe31BMGkEnNINK0CbIsL69u7bn+/v4N9SqKgsbGIFKpJCSpvjFjWRYMw0C5XC6XSqXZUql0
+Y3JyMsO++uqrXwXAb9u2LRAMBrvcbvceRVFaRkZGOgghdbMVi0U0NDSAZdm7qmgAwG5XkUgtYFW2
+AUIAvVSAPezH3TYCKIqCx+NZahMpS/oILl269J6u66Oapt2cn58/PzU1dX1wcDABoMyGw+FAQ0OD
+GggE2p1OZ6/dbt8my7IvmUx65+fnV4Ej91ywG9Uq6CVCdRUOBYCiYFrmXesEFjM/y6rH43K5vD6f
+z9B1XRVF0RQEgZdlWUilUjl2//7970YiEVkURY8gCDzLsmAYBsViEbFYrE6RoijI5/OoVqt3VbcS
+QpBKz8Lmi6BarSCbTsIyTdhdHsg2FaJsQyabhWEYd10P5/M5yPIn7kxRFFpaWjojkUinaZqoVqtf
+K5fLhq7rmYmJiRKrqmrE5XItV0sra87V4vf7MTExAU3T4HA4PrUL5nI5TCdSaNu0FUee+wfcunEd
+AIHq9uNLT/85PP4gbgyfQ6FQgN1u/9R6DcNAIpHAnj17YBj1eXWNx1K5y0mS1KCqKthr1679WS6X
+89nt9l5VVbfYbLYmURRFTdM4AGJNgWVZaGrajIGBc0gmk3A4HFBV9VMBGxg4Bwh2zExGce2jMwiH
+QuA4DtHoCN5541/xwKNfRnq+iLGxUXi93roVu53E43EUCnn4fP662l3TNL1QKBjlclkvFou38vn8
+SC6Xuzw9PZ1k3W73b/ft24dvf/vbjMvlaunu7u5zOp2tsVhsFyGk7oxxuVxwuz344IP3EQgEwLLs
+HbuYyUQCrx8/CefmLgydO4nQpgDS6RQ4jseOrR1o9vO49N5J+De34Y3jJxAOh7FpU9Mdm4WEEJw6
+9Uc0N7fUYbAsCwMDAyeTyeTFfD4fHRkZ+SCdTsdefPHF6rFjx8Amk8mnT5065f3e9763XVXVblVV
+m0VRVK9evcp9+OGHdZPQNA3VbsfRY8fQ3b0VHR0dcLlca46pmqTTKfz8l7+Es6kDmZk4wn47tj60
+EyzLgOc4NDc1QuR5/NNrx+HybUd0KIGXX34Fhw8fRmNjIwRB2HB7fXzxIs6dO4dvfetbsCyrDuPu
+3bsf2bZt2z5d14sPPvhgPJfLDR8/fvxyMplMsb29vf/c2dlJMQyzvI9pmoaiKOtatVKuINjWg395
+9V/x9KGvIhJpg91uh6qqy4mBri/gwoULePnV1yA3tOK+3f14/flfIuCVl3tWc/OLwc/jdsIyTciK
+DX2PHMDZE0fwq1/9CgcPHEB3dzccTmfd2QwAw0ND+F8//zmsanXN+QsAiqJIDodDUlXV7vV6g5Zl
+fdY0TVy/fp2wmqbFi8WiIgiCi+d5plYibuRGC+Uytu7qg1k18Lt/fhltLU1oCYVgs9lgWRbS6TTG
+ozHkdAtbdj2EUFsXKIpCqLMHF868gYFLQ1BsjkUiFIXpRArh7p3YFIqA43nsf/Iwrpw/g1/8+jcI
+bWrA1u4t2Ny0GZIsoVgsYnh4BBeuXENo216kY0OoGgbWS5Rq3UzTNFGpVExd1+c1TSuxb7311kNj
+Y2Muv9/f6XQ6t6uq2itJki8ej/sIIa2rlVQqFXA8j7buXgQ2NSM2NoQPh2/CMCpgOR52lxctO/fD
+39gEluNByGLXo/f+h+BpaMJ7x1/FU088BqfThVQ6heuJEj7zwOeXjWx3ubH3809gLrMb8YlRvHtx
+BPqZ8wAhYDkenoYm9D1xGLKiInXjGqpmdQ3ReDwetdvt6XK5nC4UClez2ezlRCIxMj09nWWj0Wic
+oqiZcDicDoVCKY/Hk1cUpTWVSnWtJmxZFoyqCY4XQCwLdqcHO+5/aLFDRQiw1L6ttVgty1xOVBiG
+RSjShWioHWOjo1DtKqZuJRHZ/fBS8vBJFcWwLLyBILyBIEzThFmtAiBgWG552ywsaCCgYJrWmtVN
+pVJTU1NTI5qmRbPZ7IexWGw0Go2mCCEV9tChQy/86Ec/8iuKEpFluUEURYXnedhsNrz77rtrrGea
+FhimlsST+iyHkLq7zrrmOyEgINj5wMO4ePYUbkZn0NKxFYFNzSBk424IwzB153Ity6MpCqAoWKsy
+NIqisHPnzod6e3sfMgwDuq5rpVIpWSqVxg8dOpRkm5ubv9He3l6nsBa81uwLy4JFrMXAg7sUigIh
+FuxON/Y/+Z/q0tS7za4W1dEAKBCLrFtf12KRIAiyw+EIAwibpgn2xo0bv6Moymez2dplWQ5KkqTw
+PE+tDPUrjWFZiwa5l2vr1bcEq686707Z4odF1uJcEayIruulUqmUKBaLozdu3EixR44c+Q5FUUww
+GPS2trZ2eL3e+1VVbR0dHe22LOtzdYSxtBr03b0MsMjrzuPvhji15NKrCxnLsnDx4sV3isXicKlU
+is7Ozp6fmJgYm56eThNCqmx7e3t4//79bp/P17UUpXtkWfYWi0Xf6OjoKuCLe3TRnT4t2UVADE2D
+Y2nwLAOGXsxzTcuCUbVQqZqomtZdufZieFx06dWGCAaD4ZaWFpuu62Gfz9cQCASupNPpofb29gy7
+b9++0+3t7YogCE6O4+ilTgHm5uYwNja2LvhP22OuEbVJHGwiD55lQNP1z1qEwKhaKOoVFLQKzDu0
+c1cwWzLa2qC1adOmUHNzc2jJtb9QLpetSqWSGxsbK7KSJAUVRWFWZlp3nPAOf66RFTgWblWExG/c
+MKApCgLHgGdFiByLTF6DYd6ZdA2ntc6xtPLvDMNAFEWaZVmXJEl29sqVK1/PZrN+u92+3W63b1VV
+NSSKolooFAQA9XkbWelOtxeRZ+FzyOBZZvnRjZ4iSwAVkQMhEtJ5DZZ1e/emKApY6pGvlkKhoM3P
+z5d1XS8Wi8WbuVxuKJfLXZqenk6ygUDgyGOPPYZvfvObrNvtbtmyZctep9MZicViO1dXSzXE5DYB
+iBACjmXgtUvLZO/kFCv/pogcFio88lr5tkaqkV4dpS3LwkcfffRmJpO5mMvlJq5fv34ulUrFfv/7
+3xtHjhwBm8lk/uLtt9/2/vCHP9yuqmqXzWYLiqIoXLlyhTt//vz60DbgWws6TkWAwG18I7CxsRZJ
+2GUeWtlA1bTqL9/WIbw6aNE0jT179jza29u7v1wul/ft2zeTz+dHT5w4cTmTySTZbdu2/Z/Ozk7Q
+NL1clVAUtW4RXpv6disscgwUkcO9SI0bzzIQeRbFhcodBlPrYpFlWVAURZAkyeZyuTyEkG2maX7F
+4XCAzefzI9ls1iaKolcQBJHjuI1bLEu5MtZp4tVWVxF5MDR9R3e8PXEKIrdI+LZHFUXd9ngnhGAp
+vSzruj6bz+cL7Jtvvrnv6tWrakNDQ8TtdveoqrpTkqSGaDTaSAjpWrsCG3ctaZqCxC+68r2SrQnP
+0qApCha5LaN1SUaj0RFZlmd0XU/k8/nLmUxm8NatW2PpdDrPxuPxTDweL+7cuROmabKGYdhFUazk
+crk1PRYK1KJRSW396ifkGBos8+mTktsJyzJgGBpWdYP27eKrBeuufi6Xy2YymXi5XJ6cm5sbnpmZ
+Gb948eIMAJ09fPjw0XA47JJlOSTLslcQBJ7jOEiShNOnTy8SrSml8AnhtXzBMTTuJS1elzBNgWdp
+GNWN+9W1QqduUSgKO3bs6Ovt7e1bunkwNE3LPPbYY7EbN25k2WAw+MWWlpY1d0s1MU0TmqYtvaq0
++O+T5L8eAMPQ91YIrCMURUHgWJR0Y63nUliut2uZ4cLCAkzzE+PQNA2O48DzPKeqagMhpKFcLoON
+RqO/sCzLoyjKFkVRmiVJcvI8z9QerlarOHHiBBwOB7xez2LPC4sX4oRaiYSAJgSmWQXIpykVyB3H
+0bDAUEtjV0nVqgKWCYZhcPPmTZw4cWL5nY+lSgmGYVgLCwvzxWJxslAojMTj8RS1FAXpQCDg6ujo
+aPb7/d2yLPsHBwc/axjG10VRhGmacDqdaGpqQiKRgL+xCYIoroFBUxTojQLnpyiu1gwhBOsljhQA
+07IwFYvC5/UgmUxifn4eDMNA13VwHPdKT0/POV3X06lUanh0dPTmzMzMHCHEZJdyTovn+QzLspnN
+mzd/3NPTg5deeunx1tbWJ0VRlBiGQT6fx9WrV0FRFGZnZ+/RUf99haIozGUzyzkzAFQqlYWRkZHf
+/eAHPzh+7do1ZLNZ8Dz/ya3KbfSpHo/nv6x4I/7fKRz9hwmpvRGfyWT+G4DieoP+P3X284K/8yLU
+AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDIxLTA1LTA0VDEyOjEwOjUzKzAwOjAwtNpcCwAAACV0RVh0
+ZGF0ZTptb2RpZnkAMjAyMS0wNS0wNFQxMjoxMDo1MyswMDowMMWH5LcAAAAASUVORK5CYII=" />
+</svg>
diff --git a/assets/scss/_styles_project.scss b/assets/scss/_styles_project.scss
new file mode 100644
index 00000000..8b789837
--- /dev/null
+++ b/assets/scss/_styles_project.scss
@@ -0,0 +1,40 @@
+@import 'td/code-dark';
+
+code {
+    tab-size: 4;
+}
+
+.playground-editor {
+    /* make the editor scrollable */
+    overflow: auto;
+}
+.playground-editor:not([style*="height"]) {
+    /* set a default max-height of 20 lines that is resizable (resizing will set
+     * style="height: ..." which invalidates this style) */
+    max-height: calc(20em * var(--bs-body-line-height) + .375rem * 2);
+}
+
+/* Match the appearance of a Bootstrap <textarea>, including the focused state
+ * (for accessibility). */
+.playground-editor {
+    border: solid 1px var(--bs-border-color);
+    border-radius: var(--bs-border-radius);
+    box-shadow: var(--bs-box-shadow-inset);
+    transition: border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out;
+    resize: vertical;
+}
+.playground-editor > .cm-editor {
+    background-color: var(--bs-body-bg);
+    outline: initial;
+    height: 100%;
+}
+.playground-editor .cm-content {
+    padding: .375rem 0; /* match Bootstrap in vertical padding */
+}
+.playground-editor .cm-scroller {
+    line-height: var(--bs-body-line-height); /* match Bootstrap */
+}
+.playground-editor:has( > .cm-focused) {
+    box-shadow: var(--bs-box-shadow-inset), 0 0 0 0.25rem rgba(4, 110, 143, 0.25);
+    border-color: #82b7c7;
+}
diff --git a/assets/scss/_variables_project.scss b/assets/scss/_variables_project.scss
new file mode 100644
index 00000000..3711ec90
--- /dev/null
+++ b/assets/scss/_variables_project.scss
@@ -0,0 +1,12 @@
+$gunmetal: #022f40ff;
+$pacific-blue: #38aeccff;
+$blue-ncs: #0090c1ff;
+$gunmetal-2: #183446ff;
+$blue-sapphire: #046e8fff;
+$alice-blue: #edf9fcff;
+
+$primary: $blue-sapphire;
+$blue: $blue-ncs;
+$secondary: $gunmetal;
+$light: $alice-blue;
+$dark: $gunmetal-2;
diff --git a/config.toml b/config.toml
deleted file mode 100644
index 047ef97c..00000000
--- a/config.toml
+++ /dev/null
@@ -1,32 +0,0 @@
-baseURL = "https://tinygo.org/"
-title = "TinyGo - Go on Microcontrollers and WASM"
-languageCode = "en-us"
-theme = "learn"
-
-[params]
-# Change default color scheme with a variant one. Can be "red", "blue", "green".
-themeVariant = "blue"
-# Disable search function. It will hide search bar
-disableSearch = true
-editURL = "https://github.com/tinygo-org/tinygo-site/edit/release/content/"
-disableInlineCopyToClipBoard = true
-
-[[menu.shortcuts]] 
-name = "<i class='fab fa-github'></i> Github repo"
-url = "https://github.com/tinygo-org/tinygo"
-weight = 10
-
-[[menu.shortcuts]] 
-name = "<i class='fa fa-book'></i> Godoc"
-url = "https://pkg.go.dev/github.com/tinygo-org/tinygo?tab=doc"
-weight = 20
-
-[[menu.shortcuts]] 
-name = "<i class='fab fa-twitter'></i> Twitter"
-url = "https://twitter.com/TinyGolang"
-weight = 30
-
-[[menu.shortcuts]] 
-name = "<i class='fab fa-slack'></i> Slack"
-url = "https://gophers.slack.com/messages/CDJD3SUP6/"
-weight = 40
diff --git a/config/development/server.toml b/config/development/server.toml
new file mode 100644
index 00000000..e0a11949
--- /dev/null
+++ b/config/development/server.toml
@@ -0,0 +1,6 @@
+# Internal redirect for playground share URLs.
+[[redirects]]
+  force = false
+  from = "/play/s/*"
+  to = "/play/"
+  status = 200
diff --git a/content/_index.md b/content/_index.md
index 3c2db86e..cae429c2 100644
--- a/content/_index.md
+++ b/content/_index.md
@@ -1,16 +1,77 @@
 ---
-title: "Home"
+title: "TinyGo Home"
 ---
-# TinyGo - A Go Compiler For Small Places
 
-TinyGo is a project to bring the [Go programming language](https://golang.org) to microcontrollers and modern web browsers by creating a new compiler based on [LLVM](https://llvm.org/).
+{{< blocks/cover title="TinyGo - A Go Compiler For Small Places" image_anchor="top" height="full" color="primary" >}}
 
-You can compile and run TinyGo programs on many different microcontroller boards such as the [BBC micro:bit](https://www.microbit.co.uk/) and the [Arduino Uno](https://store.arduino.cc/usa/arduino-uno-rev3/).
+![TinyGo Logo](images/tinygo-logo.png)
 
-TinyGo can also be used to produce [WebAssembly (WASM)](https://webassembly.org/) code which is very compact in size.
+<div class="mx-auto">
+	<a class="btn btn-lg btn-primary mr-3 mb-4" href="{{< relref "/getting-started" >}}">
+		Get Started <i class="fas fa-arrow-alt-circle-right ml-2"></i>
+	</a>
+	<a class="btn btn-lg btn-secondary mr-3 mb-4" href="https://github.com/tinygo-org/tinygo">
+		See the code <i class="fab fa-github ml-2 "></i>
+	</a>
+	<p class="h2 mt-5">Go on embedded systems and WebAssembly</p>
+</div>
+{{< /blocks/cover >}}
 
-Just want to see the code? Go to the Github repository at [https://github.com/tinygo-org/tinygo](https://github.com/tinygo-org/tinygo).
+{{% blocks/lead color="secondary" %}}
+TinyGo brings the [Go programming language](https://golang.org) to embedded systems and to the modern web by creating a new compiler based on [LLVM](https://llvm.org/).
 
-TinyGo also has support for several different devices such as accelerometers and magnetometers. Check out the Github repository at [https://github.com/tinygo-org/drivers](https://github.com/tinygo-org/drivers) for more information.
+You can compile and run TinyGo programs on over 100 different microcontroller boards from maker boards such as the [BBC micro:bit](https://www.microbit.co.uk/) and the [Arduino Uno](https://store.arduino.cc/usa/arduino-uno-rev3/), to industrial processors from [Nordic Semiconductor](https://www.nordicsemi.com/) and [ST Microelectronics](https://www.st.com/). [Click here for the complete list](/docs/reference/microcontrollers)
+
+TinyGo can also produce [WebAssembly (WASM)](https://webassembly.org/) code which is very compact in size. You can compile programs for web browsers, as well as for server and edge computing environments that support the [WebAssembly System Interface (WASI)](https://github.com/WebAssembly/WASI) family of interfaces.
 
 Ready to get started? [Click here](getting-started).
+
+{{% /blocks/lead %}}
+
+{{% blocks/section color="primary-light" %}}
+<link rel="stylesheet" href="playground/simulator.css">
+<link rel="stylesheet" href="playground/simulator-bootstrap.css">
+<script type="module" src="playground-home.js"></script>
+<link rel="modulepreload" href="/playground/resources/editor.bundle.min.js"/>
+<div class="col">
+	<div class="container" id="playground">
+		<h1 class="text-center">Try TinyGo</h1>
+		<div class="row px-0">
+			<div class="col col-auto">
+				<div class="input-group mb-3">
+					<span class="input-group-text">Example</span>
+					<select class="form-select example_select" disabled>
+						<option value="hello">Hello world</option>
+						<option value="arduino" selected>Blinking LED (Arduino Uno)</option>
+						<option value="circuitplay_express">RGB LEDs (Adafruit Circuit Playground Express)</option>
+						<option value="gopher_badge">Display (Gopher Badge)</option>
+					</select>
+				</div>
+			</div>
+			<div class="col col-auto">
+				<button class="btn btn-secondary playground-btn-flash mb-3" disabled>Download binary</button>
+				<a href="/tour/" class="btn btn-link mb-3">Tour of TinyGo</a>
+			</div>
+		</div>
+		<div class="playground-editor mb-3" tabindex="-1"></div>
+		<div class="simulator">{{< readfile "/simulator/simulator.md" >}}</div>
+	</div>
+</div>
+{{% /blocks/section %}}
+
+{{< blocks/section color="primary" type="row" >}}
+{{% blocks/feature icon="fa-lightbulb" title="TinyGo Playground" url="/play/" %}}
+Try TinyGo online
+{{% /blocks/feature %}}
+
+{{% blocks/feature icon="fab fa-github" title="TinyGo on Github" url="https://github.com/tinygo-org/tinygo" %}}
+See the code here
+{{% /blocks/feature %}}
+
+
+{{% blocks/feature icon="fab fa-mastodon" title="TinyGo on Mastodon" url="https://mastodon.social/@TinyGo" %}}
+Join us on Mastodon
+{{% /blocks/feature %}}
+
+{{< /blocks/section >}}
+
diff --git a/content/arduino-background.jpg b/content/arduino-background.jpg
new file mode 100644
index 00000000..7c49baa4
Binary files /dev/null and b/content/arduino-background.jpg differ
diff --git a/content/compiler-internals/_index.md b/content/compiler-internals/_index.md
deleted file mode 100644
index 6320a8b2..00000000
--- a/content/compiler-internals/_index.md
+++ /dev/null
@@ -1,9 +0,0 @@
----
-title: "Compiler Internals"
-chapter: true
-weight: 8
----
-
-# Compiler Internals
-
-Want to learn how TinyGo works? We break it all down for you here.
diff --git a/content/compiler-internals/inline-assembly.md b/content/compiler-internals/inline-assembly.md
deleted file mode 100644
index 85c30bba..00000000
--- a/content/compiler-internals/inline-assembly.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: "Inline assembly"
-weight: 4
----
-
-The device-specific packages like `device/avr` and `device/arm` provide `Asm` functions which you can use to write inline assembly:
-
-```go
-arm.Asm("wfi")
-```
-
-You can also pass parameters to the inline assembly:
-
-```go
-var result int32
-arm.AsmFull(`
-    lsls  {value}, #1
-    str   {value}, {result}
-`, map[string]interface{}{
-    "value":  42,
-    "result": &result,
-})
-println("result:", result)
-```
-
-In general, types are autodetected. That is, integer types are passed as raw registers and pointer types are passed as memory locations. This means you can't easily do pointer arithmetic. To do that, convert a pointer value to a `uintptr`.
-
-Inline assembly support is expected to change in the future and may change in a backwards-incompatible manner.
diff --git a/content/docs/_index.md b/content/docs/_index.md
new file mode 100644
index 00000000..f437f25d
--- /dev/null
+++ b/content/docs/_index.md
@@ -0,0 +1,16 @@
+---
+title: "Documentation"
+linkTitle: "Documentation"
+weight: 20
+menu:
+  main:
+    weight: 20
+
+cascade:
+  github_repo: https://github.com/tinygo-org/tinygo-site
+  github_subdir: content/docs
+  path_base_for_github_subdir: content/docs
+  github_branch: dev
+---
+
+The TinyGo documentation is organized into specific sections to help you locate the information that you need.
diff --git a/content/docs/concepts/_index.md b/content/docs/concepts/_index.md
new file mode 100644
index 00000000..391594a7
--- /dev/null
+++ b/content/docs/concepts/_index.md
@@ -0,0 +1,7 @@
+---
+title: "Concepts"
+linkTitle: "Concepts"
+weight: 4
+description: >
+  What you need to understand about TinyGo in order to use it - or potentially contribute to it.
+---
\ No newline at end of file
diff --git a/content/docs/concepts/compiler-internals/_index.md b/content/docs/concepts/compiler-internals/_index.md
new file mode 100644
index 00000000..7138ad3c
--- /dev/null
+++ b/content/docs/concepts/compiler-internals/_index.md
@@ -0,0 +1,7 @@
+---
+title: "Compiler Internals"
+linkTitle: "Compiler Internals"
+weight: 4
+description: >
+  Want to learn how TinyGo works? We break it all down for you here.
+---
diff --git a/content/compiler-internals/calling-convention.md b/content/docs/concepts/compiler-internals/calling-convention.md
similarity index 69%
rename from content/compiler-internals/calling-convention.md
rename to content/docs/concepts/compiler-internals/calling-convention.md
index 329306ec..9de91eee 100644
--- a/content/compiler-internals/calling-convention.md
+++ b/content/docs/concepts/compiler-internals/calling-convention.md
@@ -18,11 +18,11 @@ TinyGo, however, uses a register based calling convention. In fact it is somewha
 
     Note that all native Go data types that are lowered to aggregate types in LLVM are expanded this way: `string`, slices, interfaces, and fat function pointers. This avoids some overhead in the C calling convention and makes the work of the LLVM optimizers easier.
 
-  * The WebAssembly target by default doesn't export or import `i64` (`int64`, `uint64`) parameters. Instead, it replaces them with `i64*`, allocating the value on the stack. In other words, imported functions are called with a 64-bit integer on the stack and exported functions must be called with a pointer to a 64-bit integer somewhere in linear memory.
+  * Some environments don't support `i64` parameters and return values (like old Node.js versions). Therefore, when targeting browsers, TinyGo will use a special ABI where these parameters and return values are returned with `i64`, allocating the value on the C stack. In other words, imported functions are called with a 64-bit integer on the stack and exported functions must be called with a pointer to a 64-bit integer somewhere in linear memory.
 
-    This is a workaround for a limitation in JavaScript, which only deals with doubles and can therefore only work with integers up to 32-bit in size (a 64-bit integer cannot be represented exactly in a double, a 32-bit integer can). It is expected that 64-bit integers will be [added in the near future] (https://github.com/WebAssembly/design/issues/1172) at which point this calling convention workaround may be removed. Also see [this wasm-bindgen issue](https://github.com/rustwasm/wasm-bindgen/issues/35).
+    WASI doesn't have this limitation so it will always use plain `i64` values.
 
-    Currently there are also non-browser WebAssembly execution environments that do not have this limitation. Use the -wasm-abi=generic flag to remove the behavior described above and enable emitting functions with i64 parameters directly.
+    We will eventually remove support for this workaround, as it is only really needed for very old Node.js versions.
 
   * The WebAssembly target does not return variables directly that cannot be handled by JavaScript (see above about `i64`, also `struct`, `i64`, multiple return values, etc). Instead, they are stored into a pointer passed as the first parameter by the caller.
 
diff --git a/content/compiler-internals/datatypes.md b/content/docs/concepts/compiler-internals/datatypes.md
similarity index 71%
rename from content/compiler-internals/datatypes.md
rename to content/docs/concepts/compiler-internals/datatypes.md
index 5023d2a9..1683045f 100644
--- a/content/compiler-internals/datatypes.md
+++ b/content/docs/concepts/compiler-internals/datatypes.md
@@ -32,5 +32,5 @@ may be a real pointer or an arbitrary number, depending on the target platform.
 ### goroutine
 Goroutines are implemented differently depending on the platform.
 
-  * For most platforms, it is implemented as a linked list of [LLVM coroutines](https://llvm.org/docs/Coroutines.html). Every blocking call will create a new coroutine and pass itself to the coroutine as a parameter (see [calling convention]({{<ref "calling-convention.md">}})). The callee then re-activates the caller once it would otherwise return to the parent.  Non-blocking calls are normal calls, unaware of the fact that they're running on a particular goroutine. For details, see [src/runtime/scheduler.go](https://github.com/tinygo-org/tinygo/blob/release/src/runtime/scheduler.go). This is rather expensive but has the advantage of being portable and requiring only a single stack.
-  * For Cortex-M (which includes most supported microcontrollers as of this time), a real stack is allocated and scheduling happens much like the main Go implementation by saving and restoring registers in assembly.
+  * For most platforms, it is implemented as a lightweight thread similar to the main Go runtime. This means a stack is allocated per goroutine and switching between them happens by saving and restoring all registers. If the stack is too small and a stack overflow happens, you can adjust the stack size. For example, if you want an 8kB stack you can use `-stack-size=8KB`.
+  * For WebAssembly, we use [Asyncify](https://kripken.github.io/blog/wasm/2019/07/16/asyncify.html). This works most of the time, but can result in some weird edge cases.
diff --git a/content/compiler-internals/differences-from-go.md b/content/docs/concepts/compiler-internals/differences-from-go.md
similarity index 58%
rename from content/compiler-internals/differences-from-go.md
rename to content/docs/concepts/compiler-internals/differences-from-go.md
index dccdc327..0494b797 100644
--- a/content/compiler-internals/differences-from-go.md
+++ b/content/docs/concepts/compiler-internals/differences-from-go.md
@@ -7,9 +7,9 @@ weight: 8
 * Interfaces are always represented as a `{typecode, value}` pair. Unlike Go [https://research.swtch.com/interfaces](https://research.swtch.com/interfaces), TinyGo will not precompute a list of function pointers for fast interface method calls. Instead, all interface method calls are looked up where they are used. This may sound expensive, but it sometimes avoids memory allocation at interface creation.
 * Global variables are computed during compilation whenever possible (unlike Go, which does not have the equivalent of a `.data` section). This is an important optimization for several reasons:
 
- - Startup time is reduced. This is nice, but not the main reason.
- - Initializing globals by copying the initial data from flash to RAM costs much less flash space as only the actual data needs to be stored, instead of all instructions to initialize these globals.
- - Data can often be statically allocated instead of dynamically allocated at startup.
- - Dead globals are trivially optimized away by LLVM.
- - Constant globals are trivially recognized by LLVM and marked `constant`. This makes sure they can be stored in flash instead of RAM.
- - Global constants are useful for constant propagation and thus for dead code elimination (like an `if` that depends on a global variable).
+   - Startup time is reduced. This is nice, but not the main reason.
+   - Initializing globals by copying the initial data from flash to RAM costs much less flash space as only the actual data needs to be stored, instead of all instructions to initialize these globals.
+   - Data can often be statically allocated instead of dynamically allocated at startup.
+   - Dead globals are trivially optimized away by LLVM.
+   - Constant globals are trivially recognized by LLVM and marked `constant`. This makes sure they can be stored in flash instead of RAM.
+   - Global constants are useful for constant propagation and thus for dead code elimination (like an `if` that depends on a global variable).
diff --git a/content/compiler-internals/harvard-arch.md b/content/docs/concepts/compiler-internals/harvard-arch.md
similarity index 90%
rename from content/compiler-internals/harvard-arch.md
rename to content/docs/concepts/compiler-internals/harvard-arch.md
index a4d71026..0622d605 100644
--- a/content/compiler-internals/harvard-arch.md
+++ b/content/docs/concepts/compiler-internals/harvard-arch.md
@@ -5,4 +5,4 @@ weight: 10
 
 The AVR architecture is a modified Harvard architecture, which means that flash and RAM live in different address spaces. In practice, this means that any given pointer may either point to RAM or flash, but this is not visible from the pointer itself.
 
-To get TinyGo to work on the Arduino, which uses the AVR architecutre, all global variables (which include string constants!) are marked non-constant and thus are stored in RAM and all pointer dereferences assume that pointers point to RAM. At some point this should be optimized so that obviously constant data is kept in read-only memory but this optimization has not yet been implemented.
+To get TinyGo to work on the Arduino, which uses the AVR architecture, all global variables (which include string constants!) are marked non-constant and thus are stored in RAM and all pointer dereferences assume that pointers point to RAM. At some point this should be optimized so that obviously constant data is kept in read-only memory but this optimization has not yet been implemented.
diff --git a/content/compiler-internals/heap-allocation.md b/content/docs/concepts/compiler-internals/heap-allocation.md
similarity index 87%
rename from content/compiler-internals/heap-allocation.md
rename to content/docs/concepts/compiler-internals/heap-allocation.md
index 52c1e876..ea18d49f 100644
--- a/content/compiler-internals/heap-allocation.md
+++ b/content/docs/concepts/compiler-internals/heap-allocation.md
@@ -5,6 +5,8 @@ weight: 5
 
 Many operations in Go rely on heap allocation. TinyGo will try to optimize them away using escape analysis, but that is not always possible in practice.
 
+If you want to know for sure which operations allocate on the heap, you can pass the compiler flag `-print-allocs=.` to show all heap allocations. You can also do this for a subset of functions or packages, for details see [build flags]({{<ref "misc-options.md">}}).
+
 These operations currently do heap allocations:
 
 * Taking the pointer of a local variable. This will result in a heap allocation, unless the compiler can see the resulting pointer never escapes. This causes a heap allocation:
diff --git a/content/docs/concepts/compiler-internals/inline-assembly.md b/content/docs/concepts/compiler-internals/inline-assembly.md
new file mode 100644
index 00000000..72f0c9f5
--- /dev/null
+++ b/content/docs/concepts/compiler-internals/inline-assembly.md
@@ -0,0 +1,54 @@
+---
+title: "Inline assembly"
+weight: 4
+---
+
+**Warning**: inline assembly is an unstable feature and may change or be removed entirely in the future! If you want to use inline assembly, it's better to use CGo instead (and [use inline assembly in C directly]({{< relref "#cgo" >}})).
+
+The device-specific packages like `device/avr` and `device/arm` provide `Asm` functions which you can use to write inline assembly:
+
+```go
+arm.Asm("wfi")
+```
+
+You can also pass parameters to the inline assembly:
+
+```go
+result := arm.AsmFull(`
+    add {}, {value}, #3
+`, map[string]interface{}{
+    "value": 42,
+})
+println("result:", int(result))
+```
+
+At the moment, only integer types are supported as operands.
+
+## Inline assembly using CGo {#cgo}
+
+Inline assembly directly in TinyGo is unstable. A more stable way to use inline assembly is through CGo:
+
+```go
+package main
+
+/*
+__attribute__((always_inline))
+int inlineasm(int value) {
+        int result;
+        __asm__("add %[result], %[value], #3"
+                : [result]"=r"(result)
+                : [value]"r"(value));
+        return result;
+};
+*/
+import "C"
+
+func main() {
+        result := C.inlineasm(42)
+        println("result:", int(result))
+}
+```
+
+Because the `inlineasm` C function is inlined into the Go main function, there is no additional CGo overhead.
+
+Inline assembly in C also has much more features that allow it to be used more safely (for example, by correctly marking registers as clobbered). A good introduction to inline assembly is this [ARM GCC inline assembly cookbook](http://www.ethernut.de/en/documents/arm-inline-asm.html).
diff --git a/content/compiler-internals/interrupts.md b/content/docs/concepts/compiler-internals/interrupts.md
similarity index 82%
rename from content/compiler-internals/interrupts.md
rename to content/docs/concepts/compiler-internals/interrupts.md
index cc8ab89a..f167757a 100644
--- a/content/compiler-internals/interrupts.md
+++ b/content/docs/concepts/compiler-internals/interrupts.md
@@ -78,6 +78,17 @@ func (uart *UART) handleInterrupt(intr interrupt.Interrupt) {
 }
 ```
 
+## Tips, Tricks and Gotchas
+
+When writing an interrupt handler you have to take care that your code does not block. This is important because the interrupt execution typically has higher priority than your regular code. This means in case your interrupt handler code needs to wait for anything it will wait forever. In general, it is good advice to avoid the following:
+
+  * Memory allocation, for details see [heap allocation]({{<ref "heap-allocation.md">}}).
+  * Blocking on channels, better use a select with a default clause to implement non-blocking send and receives.
+  * Any IO operations like `fmt.Printf`, maybe an `LED` is more appropriate than a debug print statement.
+
+One design goal of your interrupt handler shall be to be as lean as possible. In a modern OS techniques like Bottom-Half Processing is used. This basically splits your interrupt handler in two parts the one which handles the interrupt and the part which performs the heavy lift.
+
+In languages like C/C++, there is a keyword `volatile` to instruct the compiler that a variable can change or have side effects the compiler is not aware of. This comes in handy when an interrupt handler shares variables with the rest of your code. How to handle this in tinygo see [The volatile keyword]({{<ref "volatile.md">}}).
 
 ## Troubleshooting
 
diff --git a/content/compiler-internals/microcontrollers.md b/content/docs/concepts/compiler-internals/microcontrollers.md
similarity index 88%
rename from content/compiler-internals/microcontrollers.md
rename to content/docs/concepts/compiler-internals/microcontrollers.md
index f7413d57..cf2e0237 100644
--- a/content/compiler-internals/microcontrollers.md
+++ b/content/docs/concepts/compiler-internals/microcontrollers.md
@@ -23,4 +23,4 @@ There is some support for RISC-V, in particular the [HiFive1 rev B](https://gith
 
 ## Xtensa
 
-Support to run TinyGo directly on the ESP8266/ESP32 chips should be possible once the needed support is added to LLVM. See the [TinyGo FAQ](../../faq/what-about-esp8266-esp32) for details.
+Support to run TinyGo directly on the ESP8266/ESP32 chips now exists, although is still in an early stage. See the [TinyGo FAQ](../../faq/what-about-esp8266-esp32) for details.
diff --git a/content/compiler-internals/pipeline.md b/content/docs/concepts/compiler-internals/pipeline.md
similarity index 100%
rename from content/compiler-internals/pipeline.md
rename to content/docs/concepts/compiler-internals/pipeline.md
diff --git a/content/compiler-internals/volatile.md b/content/docs/concepts/compiler-internals/volatile.md
similarity index 100%
rename from content/compiler-internals/volatile.md
rename to content/docs/concepts/compiler-internals/volatile.md
diff --git a/content/docs/concepts/drivers.md b/content/docs/concepts/drivers.md
new file mode 100644
index 00000000..f1f15eaa
--- /dev/null
+++ b/content/docs/concepts/drivers.md
@@ -0,0 +1,72 @@
+---
+title: "Drivers"
+linkTitle: "Drivers"
+type: "docs"
+weight: 35
+description: >
+  How TinyGo drivers can be used to communicate with sensors and other devices and how this works.
+---
+
+Drivers are packages to make it easier for TinyGo programs to use sensors, displays, and other external hardware that can be physically connected to a microcontroller.
+
+Here is an example of a TinyGo program that uses a BMP180 digital temperature sensor by way of the [I2C interface](../peripherals/i2c):
+
+```go
+package main
+
+import (
+    "time"
+
+    "machine"
+
+    "tinygo.org/x/drivers/bmp180"
+)
+
+func main() {
+    machine.I2C0.Configure(machine.I2CConfig{})
+    sensor := bmp180.New(machine.I2C0)
+    sensor.Configure()
+
+    connected := sensor.Connected()
+    if !connected {
+        println("BMP180 not detected")
+        return
+    }
+    println("BMP180 detected")
+
+    for {
+        temp, _ := sensor.ReadTemperature()
+        println("Temperature:", float32(temp)/1000, "°C")
+
+        pressure, _ := sensor.ReadPressure()
+        println("Pressure", float32(pressure)/100000, "hPa")
+
+        time.Sleep(2 * time.Second)
+    }
+}
+```
+
+You can find all of the TinyGo drivers in the repository located at [https://github.com/tinygo-org/drivers](https://github.com/tinygo-org/drivers).
+
+## How Drivers Work
+
+Most, if not all, microcontrollers have hardware peripheral blocks that provide low-level implementations of protocols like I2C, SPI, etc. But these blocks provide only very low level functions. They must be put together in order to actually do something functional on that microcontroller. 
+
+TinyGo defines Go language interfaces for I2C, SPI, and other peripherals, and then implements these interfaces by utilizing the microcontroller blocks and registers. This is what is in the TinyGo `machine` package.
+
+Creating a TinyGo driver for a sensor, is to consume the interfaces defined by TinyGo for that peripheral such as I2C and then to use those to implement whatever communication is needed for a particular device to work. 
+
+Here is a diagram showing a specific example of this for an MPU6050 digital accelerometer:
+
+```mermaid
+graph TD
+    U[User code]
+    U -- calls accelerometer API --> G(driver/mpu6050 package)
+    G -- calls I2C interface --> M(machine)
+    M -- provides I2C implementation --> D(device)
+    D -- define I2C block/registers --> H[Hardware]
+```
+
+For example, the MPU6050 has specific commands that it expects to be sent via I2C in order to return accelerometer data. The TinyGo driver provides functions like `ReadAccelerometer()` so you can use the sensor from a TinyGo program. 
+
+These functions call the I2C functions in TinyGo which are implemented by the `machine` package. The `machine` package then uses the `device` package for that microcontroller to call the low level MCU functions needed to get their work done.
diff --git a/content/docs/concepts/faq/_index.md b/content/docs/concepts/faq/_index.md
new file mode 100644
index 00000000..8ce36231
--- /dev/null
+++ b/content/docs/concepts/faq/_index.md
@@ -0,0 +1,7 @@
+---
+title: "FAQ"
+chapter: true
+weight: 7
+description: >
+  Here is where you can find the answers to the most frequently asked questions about TinyGo.
+---
diff --git a/content/docs/concepts/faq/what-about-esp8266-esp32.md b/content/docs/concepts/faq/what-about-esp8266-esp32.md
new file mode 100644
index 00000000..c579707f
--- /dev/null
+++ b/content/docs/concepts/faq/what-about-esp8266-esp32.md
@@ -0,0 +1,8 @@
+---
+title: "What about the ESP8266/ESP32?"
+weight: 5
+---
+
+As of September 2020, we now have support for the ESP32 and ESP8266 in TinyGo!
+
+Please see https://tinygo.org/docs/reference/microcontrollers/esp32-mini32 and https://tinygo.org/docs/reference/microcontrollers/nodemcu for more information.
diff --git a/content/faq/what-is-tinygo.md b/content/docs/concepts/faq/what-is-tinygo.md
similarity index 100%
rename from content/faq/what-is-tinygo.md
rename to content/docs/concepts/faq/what-is-tinygo.md
diff --git a/content/faq/why-a-new-compiler.md b/content/docs/concepts/faq/why-a-new-compiler.md
similarity index 100%
rename from content/faq/why-a-new-compiler.md
rename to content/docs/concepts/faq/why-a-new-compiler.md
diff --git a/content/faq/why-go-instead-of-rust.md b/content/docs/concepts/faq/why-go-instead-of-rust.md
similarity index 100%
rename from content/faq/why-go-instead-of-rust.md
rename to content/docs/concepts/faq/why-go-instead-of-rust.md
diff --git a/content/docs/concepts/low-power.md b/content/docs/concepts/low-power.md
new file mode 100644
index 00000000..6adbb64e
--- /dev/null
+++ b/content/docs/concepts/low-power.md
@@ -0,0 +1,76 @@
+---
+title: "Low Power"
+linkTitle: "Low Power"
+type: "docs"
+weight: 35
+description: >
+  How to consume less power on microcontrollers
+---
+
+Microcontrollers are usually rather non-demanding when it comes to power consumption.
+Couple hundreds mW is the most you may expect a hobby project would use.
+
+Sometimes, even that is not low enough.
+Power your project from a battery, and it'd benefit greatly from consuming less.
+
+Common scenario for such projects is sleeping most of the time, and only rarely briefly wake up to query sensors and execute actions.
+The main caveat here is if not configured properly, microcontroller and peripherals continue to consume power while your program "sleeps".
+
+The standard way to pause execution in Go is to use `time.Sleep()` function that is available in TinyGo too. Depending on the chip and effort put into its support, the efficiency of this function may vary. The only thing certain: this is _not worse_ than busy looping until a certain time has passed.  
+Still, with such high-level function as `time.Sleep()` it is not always possible to disable everything that consumes power as the decisions may depend on the application, presence of peripherals and the board used.
+
+Most microcontrollers have one or more "low power" modes, also known as "deep sleep" and, sometimes, "dormant".  
+In such modes microcontroller may consume as low as milli- or even micro-Watts.  
+TinyGo gives you low level access to hardware to try and make most of it.
+
+## Implementations
+
+Manufacturers implement different modes, depending of capabilities of their products and name these modes differently too.
+Hence no naming consistency across microcontrollers, unfortunately.
+
+Always consult "Power consumption" part of a respective datasheet to understand capabilities of your hardware.  
+When reading datasheets, keep in mind peripherals that draw power too. These include \[power\] LEDs, various sensors or co-processors usually present on development boards.
+
+Capabilities of different chips:
+- Some very good chips (like the nRF series) can go to a very low power state (just a few µA) with RAM retention and waking up from a low-power RTC.
+- Some limited chips (like the esp32) can't really "sleep" with low power -- they can disable the core and memory and reset after a predefined time losing state stored in memory.
+- Other chips need to use a special feature to go into deep sleep mode.
+
+Especially the distinction between waking up with or without RAM is important, because it greatly affects how you write software.
+
+The common way to wake up from deep sleep is to use
+[interrupts]({{<ref "compiler-internals/interrupts">}}), such as timer,
+real-time-clock or an interrupt on a pin change.
+
+### RP2040
+
+Minimal achievable power consumption is 0.18mA in "Dormant" and 0.39mA in "Sleep" modes.  
+See [RP2040 datasheet](https://datasheets.raspberrypi.com/rp2040/rp2040-datasheet.pdf#page=621), section 5.7 Power Consumption.
+
+### nRF Family
+
+[nRF series chips](https://www.nordicsemi.com/Products) are exceptionally efficient and is recommended choice for low-power projects.  
+Even with [BLE broadcasting enabled](https://devzone.nordicsemi.com/power/w/opp/2/online-power-profiler-for-bluetooth-le) it can use less power than RP2040 in its lowest power state!
+
+Minimal achievable power consumption is in the area of µA.
+
+TinyGo implements standard `time.Sleep()` very efficiently for nRF chips so you can just use it and have great results.  
+The only thing you may want to tweak is to disable the UART with help of `-serial=none` flag to go even lower than default.
+
+## The Way to Low Power
+
+> Attached [debugger]({{<ref "../guides/debugging">}}) usually blocks the low power state in chip.
+> The best way to measure when using a debugger is to flash the code, do a power cycle, and then measure.
+
+> The changes discussed in this paragraph shall be made in TinyGo and not in your application code.  
+> These are `runtime` and/or `machine` packages, in files related to your target.
+
+Following steps shall help you achieve low power consumption:
+
+- Put a `for { arm.Asm("wfi") }` loop before anything else is initialized (at the beginning of [Reset_Handler](https://github.com/tinygo-org/tinygo/search?q=%22export+Reset_Handler%22)).  
+  _`wfi` pauses the processor, puts it in "wait for interrupt" state. And when inserted before any initialisation, this ensures no internal subsystem is running consuming power._
+- Measure the current, this should be the lowest consumption as advertised for the chip.
+- If it is higher than that, investigate why (it could be a power LED, regulator, some clock that's enabled by the bootloader, maybe other things).  
+  _Usually this ranges somewhere between 1µA and 100µA, depending on the low-power capabilities of the chip. Don't continue until you really do reach the lowest possible power consumption._
+- Slowly move the loop to later in the code, until you move it into the main function.
+- There are probably things initialized by default that consume current, like UART, PLLs, different clocks. Disable them before continuing, or investigate why they consume power.
diff --git a/content/docs/concepts/package-organization.md b/content/docs/concepts/package-organization.md
new file mode 100644
index 00000000..3e3bcccf
--- /dev/null
+++ b/content/docs/concepts/package-organization.md
@@ -0,0 +1,29 @@
+---
+title: "Package Organization"
+linkTitle: "Package Organization"
+type: "docs"
+weight: 35
+description: >
+  How your code runs and fits in with the packages provided by TinyGo
+---
+
+```mermaid
+graph TD
+    Y[package main] --> M{{package machine}}
+    Y --> G(standard Go packages)
+    G --> R(package runtime)
+    Y --> R
+    R --> M
+    M --> D{{package device}}
+    D --> H[Hardware]
+```
+
+The `main` package is the main entry point to your program, just like any other Go program. Typically you will import other packages and then call them from your package. The subpackages for your application are compiled in the same way as any other Go package by the TinyGo compiler. At some point, you will want to call the Go standard library packages to do things.
+
+The standard Go library packages along with any third-party Go language packages are compiled and linked together by TinyGo. Their implementations will commonly call the `runtime` package for low-level functionality.
+
+The `runtime` package that will be used is the TinyGo implementation of the Go runtime. This is needed to run bare metal on whatever hardware is being targeted by your compiled code. The TinyGo `runtime` package implementation can call the TinyGo `machine` package for specific hardware features.
+
+The `machine` package is the TinyGo hardware abstraction layer. The interfaces that it exposes are the same regardless of the implementation of the target hardware. For example, to use whatever serial ports or timer are built-in to the target chip.
+
+The `device` package is a set of generated Go types, each of which wraps the low-level registers for a particular chip. You generally would only use them directly when you are adding support to TinyGo for a new chip.
diff --git a/content/docs/concepts/peripherals/_index.md b/content/docs/concepts/peripherals/_index.md
new file mode 100644
index 00000000..9f0a764c
--- /dev/null
+++ b/content/docs/concepts/peripherals/_index.md
@@ -0,0 +1,6 @@
+---
+title: "Peripherals"
+weight: 5
+description: >
+  Background on microcontroller hardware, such as GPIO and I2C.
+---
diff --git a/content/docs/concepts/peripherals/gpio.md b/content/docs/concepts/peripherals/gpio.md
new file mode 100644
index 00000000..59783907
--- /dev/null
+++ b/content/docs/concepts/peripherals/gpio.md
@@ -0,0 +1,135 @@
+---
+title: "GPIO"
+weight: 1
+description: |
+  How to control pins directly using GPIO.
+---
+
+For API documentation, see the [machine API](../../../reference/machine#gpio).
+
+GPIO is the most basic form of interacting with the outside world on a microcontroller. It makes it possible to set a pin to low (connected to ground) or high (connected to VCC, usually 3.3V or 5V). GPIO also allows reading whether a pin is low or high.
+
+## Controlling GPIO output
+
+You might have seen the classic blinking LED example before, but here it is again:
+
+```go
+package main
+
+import (
+    "machine"
+    "time"
+)
+
+func main() {
+    led := machine.LED
+    led.Configure(machine.PinConfig{Mode: machine.PinOutput})
+    for {
+        led.Low()
+        time.Sleep(time.Millisecond * 1000)
+
+        led.High()
+        time.Sleep(time.Millisecond * 1000)
+    }
+}
+```
+
+This example continuously sets an output (connected to an LED) to on or off.
+
+Let's go through it line by line.
+
+```go
+led := machine.LED
+led.Configure(machine.PinConfig{Mode: machine.PinOutput})
+```
+
+`machine.LED` is a constant of type `machine.Pin`. It is simply a named numeric type (`type Pin uint8`) to identify a given pin on the board. It has a few methods to interact with these hardware pins. It can also be used in other peripherals, but more on that in other guides. Most developer boards contain an on-board LED which you can access through `machine.LED`, but you can also use any other pin defined on the board.
+
+The first method that's important is the `Configure` method. All hardware in the TinyGo machine package needs some initialization first before it can be used. In this case, only a single setting needs to be configured: the `Mode` field which indicates the pin mode. You could compare the `Configure` method to the Arduino [`pinMode`](https://www.arduino.cc/reference/en/language/functions/digital-io/pinmode/) function.
+
+After configuration, you can set it to either low or high:
+
+```go
+led.Low()
+led.High()
+```
+
+Or you can set it to a binary (`bool`) value, where low is false and high is true:
+
+```go
+led.Set(true) // same as led.High()
+```
+
+Again, low means that it is connected to ground while high means that it is connected to VCC, which is usually 3.3V or 5V.
+
+**Warning**: make sure to limit the amount of current you draw from these pins. It is usually fine to drive a LED directly as long as you use a resistor (330Ω is safe in most cases) but you usually cannot drive anything more powerful directly, especially something as powerful as electromotors. Instead, you should look into transistors and MOSFETs (hint: MOSFETs are often easier to work with as they have a digital input).
+
+You might notice that setting an onboard LED to low often turns it on while setting it to high turns it off. This is because LEDs on developer boards are often connected in a somewhat counter intuitive way: with the anode connected directly to VCC and the cathode connected to the output pin (with a resistor in between somewhere, of course). I believe this configuration is historical: chips might be able to "source" (provide) more current on VCC than they can "sink" current towards GND.
+
+## Reading GPIO input
+
+You can also read binary input from the outside world. This needs a slightly different configuration:
+
+```go
+pin := machine.BUTTON
+pin.Configure(machine.PinConfig{Mode: machine.PinInput})
+```
+
+This configures the pin as a GPIO input. There are two other modes (`machine.PinInputPullup` and `machine.PinInputPulldown`) that will be covered later in this guide, but for now this will be good enough.
+
+After configuring, you can read the current state of the pin using the `Get` method:
+
+```go
+value := pin.Get()
+```
+
+Like before with `Set`, `true` means high while `false` means low. So if the pin is connected to VCC (directly or through a resistor) you will read `true` while if the pin is connected to GND you'll read `false`.
+
+This might raise the question: what if the pin is not connected to anything? In that case it is in an intermediate state called "floating". What you will read is entirely unpredictable, it might be either high or low and this state might randomly change (or not) even by subtle changes such as moving your hand near the pin. This state is generally undetectable. Therefore, you should always avoid floating inputs if possible.
+
+The way to avoid floating inputs is through pull-up or pull-down resistors. You can read more about them [here](https://learn.sparkfun.com/tutorials/pull-up-resistors/all). In short, it connects a resistor with relatively high resistance to VCC or GND, usually somewhere around 10kΩ. You can think of it as pulling the input signal in a certain direction: a pull-up resistor gently pulls the input signal towards VCC while a pull-down resistor gently pulls down the signal to GND - all to avoid letting the input signal float in the middle and causing all kinds of issues. Of course, this pull is quite gentle so if you also connect the input directly to GND or VCC (for example with a button) the signal will still change, while avoiding the floating middle state.
+
+You can set the pull mode as part of the configure step:
+
+```go
+pin := machine.BUTTON
+pin.Configure(machine.PinConfig{Mode: machine.PinInputPullup})
+```
+
+This simply adds an extra resistor from the pin to VCC - all in software! There is also `machine.PinInputPulldown` but it is slightly less commonly supported in microcontrollers so if it doesn't matter which way you pull, it's generally a good idea to use a pull up rather than a pull down.
+
+Of course, instead of using a pull mode in software you can also connect a physical resistor to the pin as a pull up or pull down resistor. This has the advantage that you precisely control the resistor value.
+
+**Warning**: make sure the input voltage is within the allowed range of the chip. Many chips will tolerate an input slightly out of the VCC..GND range (for example, allowing VCC+0.3V) but it's better to stay entirely within VCC..GND to be safe. Going outside this range may stress or destroy the chip, although the damage might not be immediately noticeable.
+
+It's also worth noting that digital inputs expect exactly VCC or GND as input, but have some tolerance: the cutoff isn't exactly in the middle (VCC\*0.5V). Instead, most chips guarantee that low will be read when the voltage is below VCC\*0.3 and high will be read when the voltage is above VCC\*0.7. The area in between could be read either way.
+
+## Interrupts on pin changes
+
+Sometimes you may want to respond right away to a pin change, for example when it is connected to a button. You can do this by reading the state very frequently (every 10ms for example) but that introduces a lot of overhead and still doesn't respond right away. Instead, you can set an interrupt callback on the pin, which will be called when the pin changes state.
+
+Here is an example which can be used on a Circuit Playground Express:
+
+```go
+led := machine.LED
+led.Configure(machine.PinConfig{Mode: machine.PinOutput})
+led.Low()
+
+pin := machine.BUTTONA
+pin.Configure(machine.PinConfig{Mode: machine.PinInputPulldown})
+pin.SetInterrupt(machine.PinToggle, func(p machine.Pin) {
+    led.Set(p.Get())
+})
+```
+
+In this case, the button is connected between the input pin (here, `machine.BUTTONA`) and VCC. By configuring it with a pull down register, the button pin is normally logically low. However, when you press the button a connection is made between the button pin and VCC, which makes it logically high.
+
+The most important part is this:
+
+```go
+pin.SetInterrupt(machine.PinToggle, func(p machine.Pin) {
+    led.Set(p.Get())
+})
+```
+
+It says that it should trigger an interrupt whenever the pin changes state (from low to high or from high to low, meaning when pressing or releasing the button) and that it sets the LED output to the given state. This means that the LED output will match the button input in software. That's not very useful on its own but demonstrates how pin interrupts can be used.
diff --git a/content/docs/concepts/peripherals/i2c.md b/content/docs/concepts/peripherals/i2c.md
new file mode 100644
index 00000000..a4e68268
--- /dev/null
+++ b/content/docs/concepts/peripherals/i2c.md
@@ -0,0 +1,138 @@
+---
+title: "I2C"
+weight: 2
+description: |
+  How to interact with external I2C devices.
+---
+
+For API documentation, see the [machine API](../../../reference/machine#i2c).
+
+I2C is a widely used protocol for communication between chips because it requires only two digital pins on a microcontroller to communicate with multiple external devices on a single bus. It is not very fast however so it is primarily used for small sensors. An alternative name that is sometimes used is two-wire interface (or TWI), as it requires only two signal wires.
+
+As said, I2C uses two wires for communication:
+
+  * SCL (or Serial Clock) provides a clock signal. It is always controlled by the bus controller (usually the microcontroller).
+  * SDA (or Serial Data) goes both ways: data goes from the controller to the peripheral or from the peripheral to the controller. The protocol ensures that this goes smoothly.
+
+One important property of I2C is that multiple devices can be used on a single bus. That is, the two wires of I2C (SCL and SDA) can be connected to multiple peripheral devices. That means you can control many different peripheral devices using just two wires on the microcontroller, which is useful as pins tend to be scarce.
+
+The downside of all these features is that the protocol is not very fast. Most devices support 100kbps or 400kbps, but higher speeds aren't usually used. If you need higher speeds, SPI is another protocol that needs more wires but can easily reach 4MHz or higher speeds. Therefore, SPI is often used for displays while I2C is often used for sensors.
+
+If you want to learn more about I2C, you can read [this guide on Sparkfun](https://learn.sparkfun.com/tutorials/i2c/all) for more in-depth information.
+
+## Message format
+
+To allow multiple I2C devices on a single bus, each device has an address. You should be able to find the address in the documentation of the peripheral. Many peripherals also let you pick between two (or more) addresses by setting certain pins to high or low, but generally there is one default address.
+
+Apart from the peripheral address, the vast majority of I2C devices also use numbered registers. A typical read operation to read these registers is as follows:
+
+ 1. The controller starts a transaction by sending out the peripheral address.
+ 2. The controller writes a single byte, which is the register number to read.
+ 3. The controller reads one or more bytes from the peripheral. The first byte returned is for the register number that was set in step 2. Subsequent bytes are for subsequent registers, as the register number increases by one on each read.
+ 4. The controller stops the transaction when it has read enough bytes.
+
+You could think of this auto-increment behavior as reading a file. Step 1 opens a file (`f, err := os.Open()`), step 2 seeks to a location in a file (`f.Seek()`), step 3 reads some data (`f.Read()`), and step 4 closes the file (`f.Close()`). This auto-increment behavior is often useful and peripheral devices tend to put related registers close together for this reason, so they can be quickly read in a single transaction.
+
+Writing is very similar. The main difference is that the controller writes data to the peripheral instead of starting to read bytes after the initial register number is written to the peripheral.
+
+## Target mode
+
+Typically, I2C peripherals are used in controller mode to communicate with sensors and other devices.  In I2C target mode, the peripheral instead takes the role of the target (i.e. the role of a sensor/similar device).  In this case, the application logic is responsible for processing and responding to messages initiated by an I2C controller, according to this flow diagram:
+
+![I2C Target Flow](/images/i2c-target-flow.png)
+
+## Interacting with a device
+
+For this example, we'll use the [MPU6050](https://invensense.tdk.com/products/motion-tracking/6-axis/mpu-6050/) which is a very common (but old) sensor that measures acceleration and rotation. We won't be doing much interesting with it, but it serves as a great introduction into how to work with I2C peripherals with TinyGo.
+
+Here is the full code that we'll use:
+
+```go
+package main
+
+import "machine"
+
+func main() {
+    i2c := machine.I2C0
+    err := i2c.Configure(machine.I2CConfig{
+        SCL: machine.P0_30,
+        SDA: machine.P0_31,
+    })
+    if err != nil {
+        println("could not configure I2C:", err)
+        return
+    }
+    
+    w := []byte{0x75}
+    r := make([]byte, 1)
+    err = i2c.Tx(0x68, w, r)
+    if err != nil {
+        println("could not interact with I2C device:", err)
+        return
+    }
+    println("WHO_AM_I:", r[0]) // prints "WHO_AM_I: 104"
+}
+```
+
+Let's go through it line by line. The first step is configuring the I2C hardware of the microcontroller:
+
+```go
+i2c.Configure(machine.I2CConfig{
+    SCL: machine.P0_30, // change this
+    SDA: machine.P0_31, // and this
+})
+```
+
+This configures the microcontroller I2C hardware to use the given pins. It doesn't yet interact with the external peripherals.
+
+Note that you can't just pick any pins. While some microcontrollers let you pick arbitrary pins, most are limited to just a few per I2C peripheral or do not let you pick pins at all.
+
+If the board you're using has designated I2C pins (often but not always printed on the silkscreen) you can also use a shorthand to use the default pins for that board:
+
+```go
+i2c.Configure(machine.I2CConfig{})
+```
+
+Once I2C has been configured, we can start to communicate with the MPU6050.
+
+```go
+w := []byte{0x75}
+```
+
+This creates a byte slice (of length 1) with the data that we're going to send. The number 0x75 is the register number we're going to read.
+
+```go
+r := make([]byte, 1)
+```
+
+This allocates a buffer `r` for the receiving buffer. It is a byte slice of 1, so we're going to receive just a single byte.
+
+```go
+i2c.Tx(0x68, w, r)
+```
+
+This does the actual I2C transaction. It communicates with the peripheral at address 0x68, writes the data in buffer `w`, and then reads a single byte which will be stored in buffer `r`.
+
+```go
+println("WHO_AM_I:", r[0])
+```
+
+The last line simply prints the received byte. The 0x75 register is the so-called "who am I" register, which can be useful to confirm that the I2C connection is working. In this case it is 0x68, which is received from the MPU6050 so our connection actually works! We read some data from the MPU6050!
+
+To actually use this sensor you'd need to configure it first to start the sensor, but that's outside the scope of this guide. Instead, if you want to actually use an MPU6050, there is [a driver](https://pkg.go.dev/tinygo.org/x/drivers/mpu6050) already. You can see an example [here](https://github.com/tinygo-org/drivers/blob/release/examples/mpu6050/main.go) how to use it.
+
+## Behind the scenes
+
+It may be helpful to know what is going on behind the scenes. However, if you just want to use I2C you can skip this section.
+
+ 1. The microcontroller sends a _start signal_ on the bus and clocks out the address of the MPU6050 (0x68) plus a bit to indicate it is going to write.
+ 2. It then writes the 0x75 byte on the bus.
+ 3. The microcontroller then needs to switch over to reading. It does this by sending a _repeated start_ on the bus and clocks out the MPU6050 address again but now indicating that it wishes to read.
+ 4. It reads a byte.
+ 5. It signals a _stop condition_ on the bus, to end the transaction.
+
+Here are the raw signals:
+
+![Saleae screenshot of I2C interaction](/images/i2c-mpu6050-whoami.png)
+
+You can see the clock (SCL) is going up and down quickly and the data line somewhat more randomly as it sends data back and forth. Moreover, you can see that four bytes are transmitted across the wire: 0xD0, 0x75, 0xD1, and 0x68. 0xD0 and 0xD1 are the address, shifted left by one and with the read bit first set and then cleared. From this screenshot it is not visible who send the data, but in this case the last byte was sent by the MPU6050 and the previous three were sent by the microcontroller.
diff --git a/content/docs/concepts/peripherals/watchdog.md b/content/docs/concepts/peripherals/watchdog.md
new file mode 100644
index 00000000..a9438ec8
--- /dev/null
+++ b/content/docs/concepts/peripherals/watchdog.md
@@ -0,0 +1,50 @@
+---
+title: "Watchdog"
+weight: 2
+description: |
+  How to interact with internal watchdog devices.
+---
+
+For API documentation, see the [machine API](../../../reference/machine#watchdog)
+
+Many microcontrollers include some form of watchdog peripheral.  Watchdog peripherals are used to restart the microprocessor in the event of a fault condition (typically a software bug).  Watchdogs are typically based around a fixed-frequency hardware timer that counts down from a configured value to zero.  On reaching zero a reset is triggered.  To prevent a reset the software must periodically update the watchdog, causing the counter to return to it's initial value.
+
+There are multiple variants of watchdog functionality. Some do not permit the watchdog to be disabled once enabled, others provide for multiple 'sources' enabling applications to have hardware protection over multiple subsystems.  The maximum time for the watchdog countdown can vary from hours to seconds on different hardware.
+
+Tinygo provides an abstraction supported by most watchdog hardware:
+
+1. No ability to disable a watchdog after it is enabled.
+
+2. Where supported, the watchdog is automatically disabled if a debugger is attached.
+
+3. The watchdog is not disabled during sleep (`time.Sleep`) or blocking I/O, so critical loops must take care to not sleep for too long or block on I/O indefinitely.
+
+4. A single 'source' is supported on all platforms with Watchdog support.
+
+5. The CPU is not guaranteed to reset exactly at the requested time.  Some hardware does not allow precise timing - the next largest supported timeout is used instead.
+
+A typical use of Watchdog support in a simple app would look something like this:
+
+```go
+void main() {
+    
+    // ...
+
+    config := machine.WatchdogConfig{
+		TimeoutMillis: 1000,
+	}
+    machine.Watchdog.Configure(config)
+
+    machine.Watchdog.Start()
+
+    for {
+        machine.Watchdog.Update()
+
+        //
+        // Main logic - poll GPIO, write to display, etc
+        //
+	}
+}
+```
+
+In this example, the watchdog is configured for updates at least every 1s.  One second is a safe default value supported on all hardware.  Consult `machine.WatchdogMaxTimeout` for the hardware specific maximum value.
\ No newline at end of file
diff --git a/content/docs/guides/_index.md b/content/docs/guides/_index.md
new file mode 100644
index 00000000..90ac3cf1
--- /dev/null
+++ b/content/docs/guides/_index.md
@@ -0,0 +1,8 @@
+---
+title: "Guides"
+weight: 2
+description: >
+  These guides take you through the steps required to perform specific tasks using TinyGo.
+---
+
+
diff --git a/content/docs/guides/build/_index.md b/content/docs/guides/build/_index.md
new file mode 100644
index 00000000..ef29e19f
--- /dev/null
+++ b/content/docs/guides/build/_index.md
@@ -0,0 +1,85 @@
+---
+title: "Build from source"
+weight: 2
+description: >
+  Build a development version of TinyGo from source if you want to help improve TinyGo or want to try the latest features.
+---
+
+This page details how to build TinyGo from source. If you would like to install a pre-built binary release, please see our [quick install guide](../../../getting-started/install).
+
+You'll need [Go](https://go.dev) installed on your machine to build TinyGo. The Go team provides install documentation [here](https://go.dev/doc/install).
+
+A major dependency of TinyGo is [LLVM](https://llvm.org/). You can either use a version of LLVM already on your system or build LLVM manually. Building manually takes a long time (around an hour depending on how fast your system is) so it is recommended to use a version of LLVM already on your system if that's possible. The links provided below show how to install LLVM one way or the other.
+
+After finishing building TinyGo from source remember to refer to the [additional requirements](./additional-requirements.md) page to ensure you have a fully working TinyGo installation.
+
+
+## Uninstalling TinyGo before build
+It's highly suggested you uninstall TinyGo if it is present on your computer before proceeding.
+
+***If you installed TinyGo via a package manager the command will depend on your operating system.***
+
+**Linux Debian and Ubuntu** users may run the following command to uninstall TinyGo:
+```shell
+sudo apt remove tinygo
+```
+
+---
+
+**Linux Fedora** users may uninstall TinyGo with:
+```shell
+sudo dnf remove tinygo
+```
+
+---
+
+**MacOS** users may uninstall TinyGo with the following command:
+```shell
+brew uninstall tinygo
+```
+
+---
+
+**Windows** users who installed with Scoop may run the following command to uninstall TinyGo:
+```shell
+scoop uninstall tinygo
+```
+
+---
+
+**Any OS with a manually installed TinyGo**: Remove the cloned repository. This will remove LLVM along with the TinyGo root. 
+
+You should also check if there's a remaining `tinygo` executable in your path and remove it too. 
+
+**Linux and MacOS** may run `echo $(which tinygo)` to print the path to the existing TinyGo executable.
+
+**Windows** users may run `where tinygo` to see the where any remaining TinyGo executable is located at.
+
+
+## Repository cloning (before build)
+Start with getting the source code. On Windows, you might want to install the [build dependencies](#build-dependencies) first.
+
+***Warning: Some users have encountered issues when the TinyGo source path is located within a Go workspace (indicated by the presence of a go.work file in a parent directory).
+These issues may result in runtime errors such as:
+panic: unknown type: any
+To avoid this, try building TinyGo from a directory that is outside the scope of the Go workspace.***
+
+
+```shell
+git clone https://github.com/tinygo-org/tinygo.git
+cd tinygo
+```
+
+Once cloned, you can can choose which branch to build. The default branch is the latest release, but you can also build the latest development version:
+
+```shell
+# If building released version this command is not necessary.
+git checkout dev
+```
+Once the branch is selected, pull submodules:
+
+```shell
+git submodule update --init --recursive
+```
+
+Now you are ready to build TinyGo- but you must choose whether to build with a [manual LLVM install](./manual-llvm) or with a [system installed LLVM](./bring-your-own-llvm). After building you should also read [additional requirements](./additional-requirements) to make sure you've fulfilled all the requirements for the features of TinyGo you'll be using.
diff --git a/content/docs/guides/build/additional-requirements.md b/content/docs/guides/build/additional-requirements.md
new file mode 100644
index 00000000..53ca96ae
--- /dev/null
+++ b/content/docs/guides/build/additional-requirements.md
@@ -0,0 +1,42 @@
+---
+title: "Additional requirements"
+weight: 4
+description: >
+  Build a development version of TinyGo from source if you want to help improve TinyGo or want to try the latest features.
+---
+
+We're not done yet. Some extra things need to be built before you can start using TinyGo.
+
+If you haven't already, you need to download llvm-project (for the compiler-rt sources that are needed for most architectures).
+Run the following commands inside your cloned TinyGo repository:
+
+```shell
+make llvm-source
+```
+
+To be able to use TinyGo on a bare-metal target, you need to generate some files first:
+
+```shell
+make gen-device
+```
+
+To be able to use TinyGo to build WebAssembly binaries, you will need to compile [wasi-libc](https://github.com/WebAssembly/wasi-libc) and [Binaryen](https://github.com/WebAssembly/binaryen):
+
+```shell
+make wasi-libc
+make binaryen
+```
+
+These commands may need to be re-run after some updates in TinyGo.
+
+The make target for `binaryen` is disabled in for MacOS, and the tool can be installed with:
+
+```shell
+brew install binaryen
+```
+
+There are also some extra tools you will need to install, depending on your operating system. These tools are avrdude and openocd. Check the additional requirements for your operating system:
+
+  * [Linux](/getting-started/install/linux/)
+  * [MacOS](/getting-started/install/macos/)
+  * [Windows](/getting-started/install/windows/)
diff --git a/content/docs/guides/build/bring-your-own-llvm.md b/content/docs/guides/build/bring-your-own-llvm.md
new file mode 100644
index 00000000..fc5600d2
--- /dev/null
+++ b/content/docs/guides/build/bring-your-own-llvm.md
@@ -0,0 +1,126 @@
+---
+title: "Build with system-installed LLVM"
+weight: 3
+description: >
+  How to build TinyGo with a system-installed version of LLVM.
+---
+
+⚠️ Halt! This is the system installed LLVM guide! Please check the following table and make sure you don't need the [manual LLVM install guide](../manual-llvm) instead! 
+
+
+| You need to build LLVM manually in the following cases |
+|---|
+|  You would like to use it for the ESP8266 or ESP32 chips |
+| You are using Windows. |
+| Your Linux distribution (if you use Linux) does not ship the right LLVM version. |
+
+## System installed LLVM instructions
+
+### Installing LLVM
+
+See [troubleshooting](#troubleshooting) if running into issues during the instructions.
+
+Using a system-installed version of LLVM depends on your system, of course.
+
+#### Debian or Ubuntu
+
+For **Debian** or **Ubuntu** you can install LLVM by adding a new apt repository. For more information about this method, see [apt.llvm.org](https://apt.llvm.org/). *Before copying the command below, please replace `xxxxx` with your distribution's codename*.
+
+| Distro | Version | Codename  |
+|--------|------- |------------|
+| Ubuntu | 20.04  | `focal`    |
+| Ubuntu | 22.04  | `jammy`    |
+| Ubuntu | 23.04  | `lunar`    |
+| Ubuntu | 23.10  | `mantic`   |
+| Ubuntu | 24.04  | `noble`    |
+| Ubuntu | 24.10  | `oracular` |
+| Debian | 10     | `buster`   |
+| Debian | 11     | `bullseye` |
+| Debian | 12     | `bookworm` |
+| Debian | sid    | `unstable` |
+
+```shell
+echo 'deb http://apt.llvm.org/xxxxx/ llvm-toolchain-xxxxx-18 main' | sudo tee /etc/apt/sources.list.d/llvm.list
+```
+
+After adding the apt repository for your distribution you may install the LLVM toolchain packages:
+
+```shell
+wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
+sudo apt-get update
+sudo apt-get install clang-18 llvm-18-dev lld-18 libclang-18-dev
+```
+
+#### MacOS
+
+For **MacOS**, you can install LLVM through [Homebrew](https://formulae.brew.sh/formula/llvm). The Clang/LLVM version from Apple is not supported by TinyGo.
+
+```shell
+brew install llvm lld
+```
+#### Fedora
+
+For **Fedora** users you can install LLVM from the repository. Note that the version of LLVM [varies by Fedora version](https://packages.fedoraproject.org/pkgs/llvm/llvm-libs/), for example Fedora 37 has LLVM 15.
+
+```shell
+sudo dnf install llvm-devel lld-libs lld
+```
+
+
+### Build TinyGo
+
+After LLVM has been installed, installing TinyGo should be as easy as running the following command from within the cloned `tinygo` repository (see [instructions on how to clone](./..)):
+
+```shell
+go install
+```
+
+You should now have a working TinyGo installation! What's left now is to complete the [additional requirements](../additional-requirements)
+
+Below is an example of running `tinygo version` and example output to check that
+TinyGo was installed correctly (copy only what's in front of the `$` sign to your terminal!):
+```shell
+$ tinygo version
+tinygo version 0.39.0-dev-d4189fec linux/amd64 (using go version go1.25.0 and LLVM version 19.1.2)
+```
+
+If not see the [troubleshooting](#troubleshooting) section.
+
+## Troubleshooting
+
+### `go install` command inner workings
+The `go install` command will build the `tinygo` executable and store it to your currently set `$GOBIN` directory. A couple environment variables must be set for TinyGo to work after running this:
+
+* Your go environment variable `GOBIN` points to where executables are installed with the
+    `go install` command. An empty `GOBIN` variable will default to `$HOME/go/bin` path on Linux and MacOS (same as `~/go/bin` with bash).
+    You can check Go's environment variables with `go env`. `go env GOBIN` will print
+    only `GOBIN`'s value.
+ 
+* Your $PATH environment variable should contain the `GOBIN` directory so that you can run `tinygo` from the command line! A reliable way to achieve this can be found at the [Go install page](https://go.dev/doc/install#). For linux it consists of adding the line below to the bottom of your `/etc/profile` file (before the `exit 0`):
+    ```
+    export PATH=$PATH:$HOME/go/bin
+    ```
+
+### Debian LLVM repository manual addition
+If `sudo apt-get install clang-xx llvm-xx-dev lld-xx libclang-xx-dev` does not work, where `xx` is the LLVM version required by the TinyGo branch you are building i.e: 18, please try manually adding the repository. Run the following command and try the steps above again.
+```shell
+wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
+```
+
+### GCC errors
+If you are getting an `gcc` or `g++ not found` error you most likely do not have a working C++ build environment. You'll need the `build-essential` package on Debian or `sudo dnf install make automake gcc gcc-c++` for Fedora based systems.
+
+If you are getting a build error like this, LLVM is not installed as expected:
+
+```
+# tinygo.org/x/go-llvm
+../../../go/pkg/mod/tinygo.org/x/go-llvm@v0.0.0-20221028183034-8341240c0b32/analysis.go:16:10: fatal error: 'llvm-c/Analysis.h' file not found
+#include "llvm-c/Analysis.h" // If you are getting an error here you need to build or install LLVM, see https://tinygo.org/docs/guides/build/
+         ^~~~~~~~~~~~~~~~~~~
+1 error generated.
+```
+
+This can often be fixed by specifying the LLVM version as a build tag, for example `-tags=llvm14` if you have LLVM 14 instead of LLVM 16.
+
+### Additional notes
+Note that you should not use `make` when you want to build using a system-installed LLVM, just use the Go toolchain.
diff --git a/content/docs/guides/build/manual-llvm.md b/content/docs/guides/build/manual-llvm.md
new file mode 100644
index 00000000..d81a5009
--- /dev/null
+++ b/content/docs/guides/build/manual-llvm.md
@@ -0,0 +1,103 @@
+---
+title: "Manual LLVM build"
+weight: 3
+description: >
+  How to build LLVM yourself, or "manually".
+---
+
+
+| You need to build LLVM manually in the following cases |
+|---|
+|  You would like to use it for the ESP8266 or ESP32 chips |
+| You are using Windows. |
+| Your Linux distribution (if you use Linux) does not ship the right LLVM version. |
+
+
+## Build dependencies
+***Depending on which OS you use the command to install
+the dependencies needed to build LLVM will differ.*** Skip over to the command for your Operating System (OS) in this section (OS names are bolded):
+
+
+**Linux Debian and Ubuntu** users may install all required tools this way:
+```shell
+sudo apt-get install build-essential git cmake ninja-build
+```
+
+---
+
+**Linux Fedora** users may install all required tools with:
+```shell
+sudo dnf groupinstall "Development Tools"
+sudo dnf install cmake ninja-build
+```
+
+---
+
+**MacOS** users may install these tools using [Homebrew](https://brew.sh/):
+
+```shell
+brew install cmake ninja
+```
+
+---
+
+**Windows** users may install build dependencies using [Chocolatey](https://chocolatey.org/). Install Chocolatey first, then run the following in a command prompt or PowerShell with administrative privileges:
+
+```shell
+choco install --confirm git golang mingw make cmake ninja python
+```
+**Windows** users should also use *Git Bash* (installed above) to run all the build commands like `make`. The TinyGo build system expects a Unix-like environment that is not normally provided by Windows but is included already in *Git Bash*.
+
+Choco doesn't seem to add CMake automatically to the `$PATH` variable. You can do this manually if needed, in Git bash:
+
+```shell
+export PATH="$PATH:/c/Program Files/CMake/bin"
+```
+
+## Building LLVM
+***The following instructions are common to all operating systems.***
+
+Background: *[LLVM](https://llvm.org/) is a library and collection of tools for building compilers. It is the base of many newer compilers, like Clang, Swift, and the Rust compiler so they can all build on the same high-quality base. Similarly, TinyGo uses LLVM for all its low-level optimization and machine code generation so that it can produce code that's roughly as small and efficient as all these other modern compilers.*
+
+We build LLVM from inside the TinyGo repository we cloned in the [previous step](../). The following command when run inside the TinyGo repo will take care of first downloading the LLVM source code to later build it in the next step. It places the source code in `llvm-project/` and the build output in `llvm-build/`. It only needs to be done once until the next LLVM release (every half year).
+
+Note that the build step may take some time- feel free to grab a drink meanwhile. Warnings emitted through the compilation in this part are normal as of LLVM 17.
+
+```shell
+make llvm-source llvm-build
+```
+
+When building on Windows, add CCACHE=OFF.
+
+```shell
+make llvm-source llvm-build CCACHE=OFF
+```
+
+
+## Building TinyGo
+
+Once this is finished, you can build TinyGo against this manually built LLVM:
+
+```shell
+make
+```
+
+This results in a `tinygo` binary in the `build` directory:
+
+```shell
+$ ./build/tinygo version
+tinygo version 0.39.0-dev-d4189fec linux/amd64 (using go version go1.25.0 and LLVM version 19.1.2)
+```
+
+You have successfully built TinyGo from source. Congratulations! What's left now is to complete the [additional requirements](../additional-requirements)
+
+#### Adding tinygo to your path
+
+**Linux** users may choose to run TinyGo from any directory you may want to move the built binary to a location on your path
+or add the `./build` directory to your path. The following shell command moves the TinyGo binary to `/user/bin` so that any user can run TinyGo. You may need root privileges to complete this step.
+```shell
+mv ./build/tinygo /usr/bin/
+```
+If you ran the above command, **uninstalling** TinyGo is as easy as running `rm /usr/bin/tinygo`.
+
+If you'd prefer a user-based install you can move TinyGo to your `$HOME/go/bin` directory, where the Go compiler installs binaries by default. The directory should be added to your PATH if it hasn't already been added for this to work.
\ No newline at end of file
diff --git a/content/docs/guides/compatibility.md b/content/docs/guides/compatibility.md
new file mode 100644
index 00000000..3a4eacfe
--- /dev/null
+++ b/content/docs/guides/compatibility.md
@@ -0,0 +1,68 @@
+---
+title: "Porting code to TinyGo"
+type: "docs"
+description: >
+  How to port existing code to TinyGo.
+---
+
+TinyGo tries to stay compatible with the `gc` compiler toolchain. It should over time become more and more compatible as new features are implemented. However, if you're porting existing code over then you may encounter a number of issues.
+
+## Serialization and deserialization
+
+TinyGo does have limited support for the `reflect` package, but it is not complete. This is especially noticeable with serialization/deserialization packages such as `encoding/json`.
+
+### How to fix
+
+Your best bet is is to use a different package than the standard library package. Packages optimized for speed will often work because they may avoid using reflection.
+
+## `reflect.SliceHeader` and `reflect.StringHeader`
+
+These two structs are sometimes used for unsafely casting between strings and slices. In Go, the structs look like this:
+
+```go
+type SliceHeader struct {
+	Data uintptr
+	Len  int
+	Cap  int
+}
+```
+
+In TinyGo, they look like this:
+
+```go
+type SliceHeader struct {
+	Data uintptr
+	Len  uintptr
+	Cap  uintptr
+}
+```
+
+The difference is that `Len` and `Cap` are of type `uintptr` instead of `int`. This is because TinyGo supports AVR, which is a mixed 8/16-bit architecture with 16-bit pointers. The Go language requires `int` to be either 32-bit or 64-bit. To solve this mismatch, TinyGo has chosen to use `uintptr` for the `Len` and `Cap` fields.
+
+Also, note the comment, which explicitly states that using this struct is not portable (emphasis mine):
+
+> SliceHeader is the runtime representation of a slice. **It cannot be used safely or portably** and its representation may change in a later release. Moreover, the Data field is not sufficient to guarantee the data it references will not be garbage collected, so programs must keep a separate, correctly typed pointer to the underlying data. 
+
+### How to fix
+
+Don't use these. Instead, use [`unsafe.Slice`](https://pkg.go.dev/unsafe#Slice), [`unsafe.SliceData`](https://pkg.go.dev/unsafe#SliceData), [`unsafe.String`](https://pkg.go.dev/unsafe#String), and [`unsafe.StringData`](https://pkg.go.dev/unsafe#StringData) (available since Go 1.20).
+
+For example, here is how you can unsafely cast a string to a byte slice:
+
+```go
+// Warning: don't ever write to this byte slice!
+func unsafeStringToBytes(s string) []byte {
+	return unsafe.Slice(unsafe.StringData(s), len(s))
+}
+```
+
+And here is how you can unsafely cast a `[]uint32` to a `[]byte` slice.
+
+```go
+// Warning: byte slice depends on endianness!
+func unsafeIntToBytes(slice []uint32) []byte {
+	return unsafe.Slice((*byte)(unsafe.Pointer(unsafe.SliceData(slice))), len(slice)*4)
+}
+```
+
+These functions are fully supported in TinyGo and unlike `reflect.StringHeader` and `reflect.SliceHeader` are portable across compilers and architectures.
diff --git a/content/docs/guides/contributing/_index.md b/content/docs/guides/contributing/_index.md
new file mode 100644
index 00000000..2ad00020
--- /dev/null
+++ b/content/docs/guides/contributing/_index.md
@@ -0,0 +1,68 @@
+---
+title: "Contributing"
+weight: 5
+description: >
+  Adding support for new chips, fixing bugs, improving the compiler, or otherwise improving the TinyGo project.
+---
+
+Thank you for your interest in improving TinyGo.
+
+We would like your help to make this project better, so we appreciate any contributions. See if one of the following descriptions matches your situation:
+
+### New to TinyGo
+
+We'd love to get your feedback on getting started with TinyGo. Run into any difficulty, confusion, or anything else? You are not alone. We want to know about your experience, so we can help the next people. Please open a Github issue with your questions, or you can also get in touch directly with us on our Slack channel at [https://gophers.slack.com/messages/CDJD3SUP6](https://gophers.slack.com/messages/CDJD3SUP6).
+
+### Something in TinyGo is not working as you expect
+
+Please open a Github issue with your problem, and we will be happy to assist.
+
+### Something in Go that you want/need does not appear to be in TinyGo
+
+We probably have not implemented it yet. Please take a look at our [Roadmap](https://github.com/tinygo-org/tinygo/wiki/Roadmap). Your pull request adding the functionality to TinyGo would be greatly appreciated.
+
+Please open a Github issue. We want to help, and also make sure that there is no duplications of efforts. Sometimes what you need is already being worked on by someone else.
+
+A long tail of small (and large) language features haven't been implemented yet. In almost all cases, the compiler will show a `todo:` error from `compiler/compiler.go` when you try to use it. You can try implementing it, or open a bug report with a small code sample that fails to compile.
+
+### Some specific hardware you want to use does not appear to be in TinyGo
+
+As above, we probably have not implemented it yet. Your contribution adding the hardware support to TinyGo would be greatly appreciated.
+
+Please start by opening a Github issue. We want to help you to help us to help you.
+
+Lots of targets/boards are still unsupported. Adding an architecture often requires a few compiler changes, but if the architecture is supported you can try implementing support for a new chip or board in `src/runtime`. For details, see [this wiki entry on adding archs/chips/boards](https://github.com/tinygo-org/tinygo/wiki/Adding-a-new-board).
+
+Microcontrollers have lots of peripherals (I2C, SPI, ADC, etc.) and many don't have an implementation yet in the `machine` package. Adding support for new peripherals is very useful.
+
+## How to use our Github repository
+
+The `release` branch of this repo will always have the latest released version of TinyGo. All of the active development work for the next release will take place in the `dev` branch. TinyGo will use semantic versioning and will create a tag/release for each release.
+
+Here is how to contribute back some code or documentation:
+
+- Fork repo
+- Create a feature branch off of the `dev` branch
+- Make some useful change
+- Format the change using `make fmt`
+- Make sure the tests still pass
+- Submit a pull request against the `dev` branch.
+- Be kind
+
+Please rebase (not merge) from the dev branch if your PR needs to incorporate changes that occurred after your feature branch was created. You can accomplish that via the git command line:
+
+```
+git checkout dev
+git pull --rebase origin dev
+git checkout my-feature-branch
+git rebase dev
+git push myfork my-feature-branch -f
+```
+
+## How to run tests
+
+To run the tests:
+
+```
+make test
+```
diff --git a/content/docs/guides/contributing/boards.md b/content/docs/guides/contributing/boards.md
new file mode 100644
index 00000000..36b715be
--- /dev/null
+++ b/content/docs/guides/contributing/boards.md
@@ -0,0 +1,39 @@
+---
+title: "Adding runtime support for new processors"
+weight: 1
+description: >
+  How to add runtime support to a new processor.
+---
+
+In order for a processor to support `time.Sleep()` and other things you normally expect, there are some functions that need to be implemented in the runtime for that processor.
+
+## runtime timers/sleep
+
+Functions that need to be implemented:
+
+```go
+// timeUnit defines the type of the unit of time used for that processor per tick.
+// can be measured in nanoseconds, microseconds, or milliseconds.
+// the important part is that it be consistent for any particular processor.
+type timeUnit int64
+
+// ticksToNanoseconds converts ticks to nanoseconds
+func ticksToNanoseconds(ticks timeUnit) int64
+
+// nanosecondsToTicks converts nanoseconds  to ticks
+func nanosecondsToTicks(ns int64) timeUnit
+
+// sleepTicks should sleep for d number of ticks.
+func sleepTicks(d timeUnit)
+
+// ticks returns the elapsed time since reset as a number of timeUnit ticks
+func ticks() timeUnit
+```
+
+Defining the `timeUnit` is crucial, since the unit of time for most processors is usually dependant on the system clock settings.
+
+Based on that initial information, the functions `ticksToNanoseconds()` and `nanosecondsToTicks()` can be implemented in a fairly straightforward fashion.
+
+It is with the function `sleepTicks()` that implementation details become very important. This function needs to be able to yield the processor to perform other tasks while it is waiting, in order for it to work the way that you expect with Go routines.
+
+Lastly the `ticks()` function is needed, in order for many `time` package functions to work.
diff --git a/content/docs/guides/contributing/organization.md b/content/docs/guides/contributing/organization.md
new file mode 100644
index 00000000..1f5f6347
--- /dev/null
+++ b/content/docs/guides/contributing/organization.md
@@ -0,0 +1,33 @@
+---
+title: "Package organization"
+weight: 1
+description: >
+  How code is organized in TinyGo.
+---
+
+There are many packages in the TinyGo repository. Here is an overview, and a brief description what they're for.
+
+Packages can be split in two kinds: compiler packages and GOROOT packages. Compiler packages are the ones that are part of the TinyGo compiler itself: they will generate the object files and call a linker to link them together. The GOROOT packages are the packages you can import from a program, such as the TinyGo `"machine"` package.
+
+## Compiler packages
+
+  - root: contains the command line interface for the `tinygo` command and all its subcommands
+  - `builder`: orchestrates the build
+  - `loader`: loads and typechecks the code, and produces an AST
+  - `compiler`: the compiler itself, makes little attempt at optimizing code
+  - `interp`: tries to run package initializers at compile time as far as possible
+  - `transform`: implements various optimizations necessary to produce working and efficient code
+
+There are a few more, but you don't usually need to look at them. The above packages are the most important packages. To see how these packages work together, you can also take a look at [Pipeline]({{< ref "pipeline.md" >}}).
+
+## `GOROOT` packages
+
+The `GOROOT` directory in TinyGo is actually a constructed GOROOT, cached and reused over different compiler invocations. It is a combination of Go standard library packages and special TinyGo modified packages. For example, the `fmt` package is the exact same package that's used in regular Go, while the `runtime` package is a custom implementation for TinyGo and replaced altogether.
+
+These replaced (or added) packages live in the src subdirectory:
+
+  - `src/runtime`: the replacement runtime package that contains the things you would expect of a runtime package. It implements a heap with a garbage collector, a scheduler for goroutines, channels, and perhaps less obviously: it contains various things that are not implemented in the compiler like maps, the slice `append` built-in, and various other language features. It also implements a few device specific things, namely: runtime initialization and timers (used by the time package). These last two are device specific and need to be implemented per device.
+  - `src/device`: contains hardware register access (memory-mapped I/O) without abstractions. Most of the subpackages are automatically generated. These packages are only used for baremetal programming.
+  - `src/machine`: contains a hardware abstraction layer for chips. You could think of this as the equivalent of the `os` package: it provides portable APIs for common hardware peripherals. For example, every chip vendor implements [I2C]({{<ref "i2c.md">}}) differently but the machine package wraps this in a single `*machine.I2C` type that has the same interface on any supported chip. For more information, see the [machine package doucumentation]({{<ref "../../reference/machine.md">}})
+
+There are a few more packages but these are the ones that are the most important for contributing to TinyGo.
diff --git a/content/docs/guides/debugging.md b/content/docs/guides/debugging.md
new file mode 100644
index 00000000..0f536ef8
--- /dev/null
+++ b/content/docs/guides/debugging.md
@@ -0,0 +1,125 @@
+---
+title: "Debugging"
+weight: 10
+description: |
+  Debug TinyGo programs using GDB.
+---
+
+A debugger can show you things that regular print statements cannot show you, especially on microcontrollers. The debugger used by TinyGo is called [GDB](https://www.gnu.org/software/gdb/). Debugging using GDB can sometimes be intimidating, but it is also extremely powerful. For example:
+
+  * A debugger works even when a serial port is not available. This can happen when there is a bug in an interrupt or in initialization code before the serial port is configured.
+  * You can print a stack trace, even in a panic.
+  * Depending on the optimization level and other factors, you may be able to inspect function parameters and local variables.
+  * You can step through the code and see the results on the device as you do so.
+
+By learning just a few commands such as `continue`, `breakpoint`, and `next`, you will be able to start making good use of the GDB command line. See the [GDB tutorial]({{<ref "gdb.md">}}) for an introduction. Here we will show how to get to the GDB prompt in the first place.
+
+## Requirements
+
+For debugging on your own computer (Linux, MacOS) you only really need to have the `gdb` command installed. No other programs are necessary other than the ones you already need for building programs in TinyGo.
+
+For debugging directly on a chip, you need a few more dependencies. Which dependencies you need vary by chip:
+
+  * You need a GDB variant. It depends on the architecture which one you need, but probably you'll need to install `gdb-multiarch` or `arm-none-eabi-gdb`. For other architectures you will need a different debugger (for example, [`riscv64-unknown-elf-gdb`](https://www.sifive.com/software) for RISC-V).
+  * You probably need to install OpenOCD. This program is present in most package managers and it is easiest to install it directly from there.
+  * Some boards require something other than OpenOCD, for example some Nordic Semiconductor boards require `JLinkGDBServer`.
+
+### Debian or Ubuntu
+
+You can install the most common dependencies through the package manager:
+
+    sudo apt-get install gdb-multiarch openocd
+
+### Fedora
+
+Fedora's `gdb` package comes compiled with multi arch support:
+  
+    dnf install gdb openocd
+
+To use the picoprobe as a debugger you must compile openocd from source using Raspberry Pi's openocd. [Getting Started with Raspberry Pi Pico](https://datasheets.raspberrypi.com/pico/getting-started-with-pico.pdf) Appendix A has build instructions we can modify:
+
+    dnf install automake autoconf build-essential texinfo libtool libftdi-devel libusb1-devel
+    git clone https://github.com/raspberrypi/openocd.git --recursive --branch rp2040 --depth=1
+    cd openocd
+    ./bootstrap
+    ./configure --enable-ftdi --enable-sysfsgpio --enable-bcm2835gpio
+    make -j$(nproc)
+    sudo make install
+
+### MacOS
+
+You can install the most common dependencies through Homebrew:
+
+    brew install open-ocd
+    brew tap ARMmbed/homebrew-formulae
+    brew install arm-none-eabi-gcc
+
+## Connecting a debug probe
+
+Sometimes you need a separate debug probe. Whether this is necessary depends on the board, some have a debug probe built onto the board already:
+
+  * Evaluation boards from chip vendors (such as STMicroelectronics and Nordic Semiconductors) usually have a debug probe built in.
+  * Boards from vendors such as Arduino and Adafruit usually don't have a debug probe. One notable exception is the BBC micro:bit, which does have a debug probe.
+
+If the board you want to debug already has a debug probe, you don't need any extra hardware and can go to the next step.
+
+There is a variety of choice when it comes to debug probes, but most debug probes are able to work with most boards. However, some are better supported than others.
+
+Here are some debug probes that are known to work in TinyGo for at least some boards:
+
+  * [SEGGER J-Link Edu Mini](https://www.segger.com/products/debug-probes/j-link/models/j-link-edu-mini/): this debugger can debug pretty much all ARM Cortex-M chips and is generally very reliable. However, it comes with some possible issues: it's entirely closed source, it is only allowed to be used for non-commercial purposes and it doesn't support as many chips as the full version.
+  * [Particle Debugger](https://store.particle.io/products/particle-debugger): a [DAPLink](https://armmbed.github.io/DAPLink/) based debugger that can debug practically all ARM Cortex-M chips (like the SEGGER above) and does not have limitations on how it can be used. It is also open source. While this debugger is designed for Particle hardware it can easily handle chips from other vendors.
+  * [ST-Link v2](https://www.st.com/en/development-tools/st-link-v2.html): a debugger often included on boards from STMicroelectronics and also sold separately. It is somewhat less powerful than some other debuggers as it is only intended to be used with ST hardware, even though it works with most microcontrollers that support SWD debugging. Note that many online stores sell counterfeit versions of this debugger that may be unreliable.
+  * [DIY DAPLink](https://embeddedcomputing.weebly.com/the-5-programmer-debugger.html): a debugger you can make yourself. Requires compatible board, for example [Seeeduino XIAO](https://www.seeedstudio.com/Seeeduino-XIAO-Arduino-Microcontroller-SAMD21-Cortex-M0+-p-4426.html) that costs about $5. Please see linked page for flashing and wiring instructions. For quick and easy start, it is possible to [download uf2 image](http://files.seeedstudio.com/wiki/Seeeduino-XIAO/res/simple_daplink_xiao.uf2) and flash it by simply copying it over to XIAO mounted as an external drive. Members of TinyGo community reported successfully using this method to debug XIAO and Arduino Nano 33 IoT boards.
+  * [DYI Picoprobe](https://www.raspberrypi.com/documentation/microcontrollers/raspberry-pi-pico.html#debugging-using-another-raspberry-pi-pico): Is another DIY opensource tool for the Raspberry Pi Pico. It acts as a Serial Wire Debugger (SWD) and UART to usb converter. The Raspberry Pi Pico getting started guide Appendix A page 60 has [instructions to build](https://datasheets.raspberrypi.com/pico/getting-started-with-pico.pdf) from [source](https://github.com/raspberrypi/picoprobe) or you can download and flash the [UF2 image](https://datasheets.raspberrypi.com/soft/picoprobe.uf2).
+
+Which one you should pick depends on availability and price in your area but if you want to be sure, the SEGGER debugger is a commonly used vendor-neutral debugger that supports almost all chips and is very reliable.
+
+Most ARM Cortex-M chips use a protocol called SWD which uses just two data lines, called SWDIO and SWCLK. Sometimes these are available on separate header pins, but in many cases you'll need to solder some wires to test points on the board. Where they are depends on the board but you can often find them online if you google "&lt;boardname> swd pins" or "&lt;boardname> bootloader programming".
+
+Depending on the debug probe you may need to connect some extra wires:
+
+  * `GND` goes to ground. Not always needed if you're powering the probe from the same USB power source as the board.
+  * `Vref` needs to be connected to the power source of the chip, often 3.3V.
+  * Optionally, some debuggers (such as the Particle debugger) have a built-in UART that can be useful while debugging.
+
+Check the documentation of your debug probe for more information.
+
+## Getting a GDB shell
+
+Now you have all the hardware ready, it's time to actually start the debugger! If you're lucky, TinyGo already supports debugging the board. For example, the following is all you need to debug the BBC micro:bit:
+
+```
+$ tinygo gdb -target=microbit examples/microbit-blink
+[...]
+Reading symbols from /tmp/tinygo158938990/main...done.
+Remote debugging using :3333
+0x00000000 in __isr_vector ()
+target halted due to debug-request, current mode: Thread 
+xPSR: 0x21000000 pc: 0x00003baa msp: 0x200007f0
+Loading section .text, size 0xb84 lma 0x0
+Loading section .tinygo_stacksizes, size 0x4 lma 0xb84
+Loading section .data, size 0x4 lma 0xb88
+Start address 0x71c, load size 2956
+Transfer rate: 4 KB/sec, 985 bytes/write.
+target halted due to debug-request, current mode: Thread 
+xPSR: 0xc1000000 pc: 0x0000071c msp: 0x20000800
+(gdb) 
+```
+
+If you get a result like this without error messages, you have successfully entered the GDB shell! To continue running the program, enter the command `continue`. For more information on using GDB, see the [GDB tutorial]({{<ref "gdb.md">}}).
+
+Otherwise, you may need to specify the programmer:
+
+| Programmer        | Flags                   |
+| ----------------- | ----------------------- |
+| SEGGER J-Link     | `-programmer=jlink`     |
+| Particle Debugger | `-programmer=cmsis-dap` |
+| ST-Link V2        | `-programmer=stlink-v2` |
+| DIY DAPLink       | `-programmer=cmsis-dap` |
+
+For example:
+
+```
+$ tinygo gdb -target=arduino-nano33 -programmer=cmsis-dap examples/blinky1
+```
diff --git a/content/docs/guides/driver-design.md b/content/docs/guides/driver-design.md
new file mode 100644
index 00000000..07e7bd83
--- /dev/null
+++ b/content/docs/guides/driver-design.md
@@ -0,0 +1,382 @@
+---
+title: "Driver Design and Development"
+weight: 10
+description: |
+  Developing drivers from scratch for embedded Go
+---
+# Driver Design with TinyGo
+
+This document compiles several guidelines that may be useful to developers of drivers that are used in TinyGo and upstream Go.
+That said, most suggestions are pretty general and are independent of the language used- good driver design
+in Go, Rust or C turns out to have more in common than what one may think.
+
+## General guidelines
+
+- **Avoid**: Floating point operations. 
+    - Peripherals rarely work with or return floating point representations of their measurements. More often than not you'll find they work with integers. There's a reason for this: integer operation hardware is widespread. Most small processors do not support floating point operations, and even if they do it is much slower than modern desktop PCs compared with integer operations
+    - There is huge difficulty in working exclusively with integer operations instead of floats without losing precision. If possible define the API return values of sensors with integers and work internally with floats if that is easier for you. This will allow the API to remove the internal floating point bits in the future while not breaking existing users. The usage of floats vs integers has been discussed here: https://github.com/tinygo-org/drivers/pull/345
+- **Avoid**: Heap allocations. More on that below.
+- **Avoid**: Concurrent code. For your sake, for the PR reviewer's sake and for the sake of our users.
+    - Concurrent code is already hard to write and harder to debug, and having to debug it on baremetal targets makes it much harder.
+    - Even if the reference implementation we are porting from is asynchronous or uses threads we go through the additional effort to make that code single-threaded like the case of the CYW43439 driver, ported from an async rust driver in embassy-rs. The CYW43439 driver is a textbook example of a successful high-complexity port.
+    - If possible make the API parallelizable. If not we can worry about that in the future :)
+    - **Avoid**: channels, goroutines, select statements. 
+    - **Consider using**: Mutexes for the API you believe will be used across multiple goroutines.
+- Adhere to [`drivers.Sensor`](https://github.com/tinygo-org/drivers/blob/release/sensor.go) interface when designing a driver for a sensor.
+    - The API for methods which return the actual values is still a WIP. See the discussion in the Sensor interface PR: https://github.com/tinygo-org/drivers/pull/345
+
+## Driver for a peripheral
+When designing a peripheral driver with which one interacts with over a communications bus one can usually adhere to the following rules
+
+- One package per peripheral
+    - So if your peripheral is the MPU6050 accelerometer create a new package called `mpu6050`
+    - Sometimes the logic can be shared between a family of peripherals such as the AS5601 and AS5600. In these cases one usually creates a package that contains this shared logic and x's the shared character position, so `as560x`
+
+- Define a base type `Device` for the handle to the peripheral. All interaction with the peripheral will be via methods on this type.
+    - Store HAL required for peripheral operation here such as communication buses (I2C, SPI drivers) and pins
+    - **Avoid**: using TinyGo `machine` package constructs in your driver (read as *don't import `"machine"`*). Users of the Go language (not only TinyGo) also consume the drivers package and they can't compile a program that uses the `"machine"` package. To abstract `machine.Pin` one can define `type PinOutput func(level bool)` and `type PinInput func() bool` functional interfaces.
+
+- Define a `Config` struct for peripherals with many configuration options.
+    - Define new types for configuration enums. Try to use values in the datasheet, if a register has 3 possible values for a configuration that a user may want to set in the `Config` define a type for that register value and provide the 3 exported values with that type as package level constants.
+    - **Avoid**: [Functional options](https://dave.cheney.net/2014/10/17/functional-options-for-friendly-apis) or interface options. These carry with them a higher overhead in both performance, memory and binary size. A peripheral API will never change after being manufactured so most benefits of this pattern are lost
+    - Define a `DefaultConfig` at the package level so that the user may easily instantiate a configuration. Maybe add a parameter or two to `DefaultConfig` to allow the user to easily tweak the most important parameters that they may want to change.
+    - Are some configuration parameters codependent and require calculating? Add a method on the `Config` type to set them consistently! Adding a `Validation() error` method is also useful during the `func (d *Device) Configure(cfg Config) error` call as well as letting users read the validation logic and understand what is a correct configuration. It's a great source for intuition on how the driver works!
+
+Provided is a list of drivers which adhere to these rules:
+- [tinygo-org/drivers/pca9685](https://github.com/tinygo-org/drivers/blob/release/pca9685/pca9685.go) - 16 channel PWM controller over I2C.
+- [tinygo-org/drivers/ndir](https://github.com/tinygo-org/drivers/blob/release/ndir/ndir.go) - CO2 sensor for range 0 to 10000ppm over I2C.
+- [tinygo-org/drivers/lsm6ds3](https://github.com/tinygo-org/drivers/blob/release/lsm6ds3/lsm6ds3.go) and [tinygo-org/drivers/l3gd20](https://github.com/tinygo-org/drivers/blob/release/l3gd20/l3gd20.go) - 6 dof IMU units for measuring acceleration and angular velocity over I2C. *Note: These still use the legacy I2C API which does not adhere to these guidelines and may allocate.*
+
+## Constrain memory use at compile time
+
+TinyGo allows for heap allocations and that is a wonderful feature but can also subject embedded Go users to some pain
+if the drivers they use make heavy use of heap allocations. 
+Heap allocations over time can crash your program if memory becomes sufficiently fragmented. This is a huge problem for users who want their programs to run a long time.
+
+Below is a short recap on heap allocations. There is also a separate section on this page, see the compiler internal page [Heap Allocations]({{<ref "heap-allocation.md">}}) for a more in depth dive.
+
+
+### Heap allocations: an introduction
+The most common source of heap allocations in TinyGo drivers are in bus communications. Take for example the following code:
+```go
+type Device struct {
+    spi drivers.SPI
+}
+
+func (d *Device) readRegister(addr uint8) (value uint8, err error) {
+    var data [2]byte
+    err= d.spi.Tx([]byte{addr, 0}, data[:])
+    return data[1], err
+}
+
+
+func (d *Device) writeRegister(addr, newValue uint8) error {
+    var data [2]byte
+    return d.spi.Tx([]byte{addr, newvalue}, data[:])
+}
+```
+
+The code above takes two buffers and passes them to the `drivers.SPI` interface `Tx` method as slices.
+Slices are referential data structures, which is to say, the **data structure contains a pointer**.
+This is a pointer to the start of the data to be sent over the bus.
+
+In go we are not aware of this since we never interact with the low level representation of a slice:
+```go
+type slice struct {
+    data      *type // Points to the first element of the slice:  &s[0]
+    length    int   // This is returned when calling builtin len: len(s)
+    capacity  int   // This is returned when calling builtin cap: cap(s)
+}
+```
+Why is it important to know slices are referential? Well it is because the compiler is aware of this and will check
+referential arguments to function and "escape" them if it can't prove their reference (pointer) is not held by the calling function.
+When a reference is escaped it will be forced to be heap allocated by the compiler.
+
+Returning to the `Device` example above we started with: any referential argument to `spi.Tx` will escape since the `Tx` method is unknown at compile time since
+`spi` is an interface. So every time we call `writeRegister` or `readRegister`, at worst two heap allocations will be performed, one being the `data [2]byte` array
+and the second being the inline composite literal slice declaration `[]byte{x, x}`. Usually heap allocators have limitations on size allocated so it is likely that more than 4 bytes are allocated for every call.
+
+### Heap allocations: Mitigations
+Luckily it can be relatively easy to mitigate heap allocations and eliminate them altogether. To do so with a driver that uses slices for bus communications one can include the array memory within the device struct. This can solve many such cases of heap allocations, but there are few cases where data to be read/written is also variable length, which we'll deal with later on.
+
+```go
+type Device struct {
+    spi      drivers.SPI
+    bufRead  [2]byte
+    bufWrite [2]byte
+}
+
+func (d *Device) readRegister(addr uint8) (value uint8, err error) {
+    // The assignment below is equivalent to a uint16 assignment to the compiler.
+    // Static arrays in Go are not pointers so this will always be on the stack.
+    d.bufWrite = [2]byte{addr, 0} 
+    err= d.spi.Tx(d.bufWrite[:], d.bufRead[:])
+    return d.bufRead[1], err
+}
+
+
+func (d *Device) writeRegister(addr, newValue uint8) error {
+    d.bufWrite = [2]byte{addr, newValue}
+    return d.spi.Tx(d.bufWrite[:], d.bufRead[:])
+}
+```
+| Note on Go's array type in TinyGo |
+|------|
+| Note the use of static arrays types like `[2]byte`. "Arrays", as they are called in Go, if small enough will always be stack allocated. TinyGo currently has a **Max Stack Object Size** configuration which runs around the 256 byte size. That said, this fact is not relevant in this case since the array is attached to the `Device` struct which almost certainly is heap allocated. Most drivers, if not all, initialize and use a pointer type (`*Device`). If the `Device` is heap allocated then the arrays it contains will also be heap allocated- and this is OK! Remember, we are trying to constrain our allocations, not completely eliminate heap allocations. We win if during the lifetime of the program there are **ZERO** heap allocations. Allowing heap allocations at initialization is a good practice and actually encouraged in [NASA's coding standards for extraplanetary missions.](https://en.m.wikipedia.org/wiki/The_Power_of_10:_Rules_for_Developing_Safety-Critical_Code) |
+
+
+The semantics for reading and writing data over the SPI bus are hypothetical, what is important is to take note on how to 
+deal with variable length buffers. See [SliceTricks](https://go.dev/wiki/SliceTricks#additional-tricks) for more tips on slice manipulation.
+```go
+const maxCommSize = 32 // Never send more than 32 bytes in a single transaction.
+
+type Device struct {
+    spi   drivers.SPI
+    wdata [maxCommSize]byte
+    rdata [maxCommSize]byte
+}
+
+func (d *Device) Configure() error {
+    // Since the argument buffer is not passed into Tx call,
+    // data does NOT escape and may be stack allocated.
+    data := []byte{1, 2, 3, 4}
+    return d.writeData(CONFIG_REG, data)
+}
+
+func (d *Device) writeData(addr uint8, data []byte) error {
+    n := copy(d.wdata[1:], data) // First byte reserved for address.
+    d.wdata[0] = addr
+    return d.spi.Tx(d.wdata[:n+1], d.rdata[:n+1])
+}
+
+func (d *Device) readData(addr uint8, data []byte) error {
+    for i := range d.wdata {
+        d.wdata[i] = 0 // Clear write data buffer.
+    }
+    dlen := len(data)
+    d.wdata[0] = addr
+    err := d.spi.Tx(d.wdata[:dlen+1], d.rdata[:dlen+1])
+    if err != nil {
+        return err
+    }
+    copy(data, d.rdata[1:])
+    return nil
+}
+```
+
+## Multi-protocol devices
+Some devices support SPI and I2C interfaces (UART, RS485, etc.). What's the ideal approach to this? Should one generate a separate driver for each protocol?
+
+The answer is, as is usual in engineering: "it depends". That said more often than not a peripheral which supports different protocols shares a whole lot of 
+functioning. Take for example the Honeywell HSC TruStability pressure sensors. These are VERY simple pressure sensors which come in SPI and I2C varieties.
+One can write a driver that shares the underlying shared logic like so:
+
+```go
+package hsc
+
+// device implements the shared logic between Honeywell HSC pressure sensor varieties.
+type device struct {
+    // calibration factors.
+    k1, k2, k3 uint32
+    lastRead   uint32
+}
+
+func (d *device) update(bridgeData []byte) error {
+    if bridgeData[0] & (1<<7) != 0 {
+        return errors.New("data unavailable")
+    }
+    d.lastRead = uint32(bridgeData[0])*d.k1 + uint32(bridgeData[1])*d.k2 + uint32(bridgeData[2])*d.k3
+    return nil
+}
+
+// Pressure implements the drivers.Sensor API for pressure sensors.
+func (d *device) Pressure() uint32 {
+    return d.lastRead
+}
+
+type DeviceSPI struct {
+    device
+    spi        drivers.SPI
+    wbuf, rbuf [4]byte
+}
+
+// Update implements the drivers.Sensor API.
+type (d *DeviceSPI) Update(which drivers.Measurement) error {
+    if which&drivers.Pressure == 0 {
+        return nil
+    }
+    err := d.spi.Tx(d.wbuf[:], d.rbuf[:])
+    if err != nil {
+        return err
+    }
+    return d.update(d.rbuf[1:4])
+}
+```
+| Note on `drivers.Sensor` API (`Update`/`Pressure`) |
+|----|
+| When designing a sensor API be sure to read [this PR](https://github.com/tinygo-org/drivers/pull/345). It is a good practice to separate the update from reading sensor data to have a way of allowing users of the sensor API to either do a calculation with the most recently read pressure or update the latest pressure value. This is because it is costly to update a pressure value and at times some sensors can also get multiple different readings like pressure and humidity in a single call. This API exposes this functionality in a composable and performant way. Users are responsible of calling `Update` regularly and having applications call the sensor value method (`Pressure`/`AngularVelocity`/etc) |
+
+There are times where the logic is much more complex and having separate types for different protocols would make the driver implementation much harder to read. 
+In these cases it is justified to have a single `Device` type which has a generic bus interface.
+
+```go
+func NewI2C(i2c drivers.I2C) *Device {
+    return &Device{
+        bus:bus{i2c:i2c, isSPI:false}
+    }
+}
+
+func NewSPI(spi drivers.SPI) *Device {
+    return &Device{
+        bus:bus{spi:spi, isSPI:true}
+    }
+}
+
+type Device struct {
+    bus
+    // ...
+}
+
+type bus struct {
+    spi drivers.SPI
+    i2c drivers.I2C
+    wbuf, rbuf [4]byte
+    isSPI bool
+}
+
+func (b *bus) ReadRegister(addr uint8) (uint8, error) {
+    if b.isSPI {
+        // SPI logic to read register.
+    } else {
+        // I2C logic to read register.
+    }
+}
+```
+
+
+
+## Hot loops
+Hot loops are a natural part of writing drivers. Sometimes you need to check a driver state before proceeding like during initialization.
+If hot loops run a couple of times the impact is negligible (but one still must mitigate risks of hot loops!). An issue does arise when the loop happens thousands  or even millions of times.
+Below is an example of a hot loop in which the developer is debugging to see how many times the hot loop runs:
+
+```go
+func (d *Device) Configure(cfg Config) error {
+    d.Reset()
+    start := time.Now()
+    hotloops := 0
+    for !d.IsConnected() {
+        hotloops++
+    }
+    // Make sure to not print in hot loop when measuring!
+    println(time.Since(start).String(), "elapsed during hot loop in Configure with calls done=", hotloops)
+    // ...
+}
+```
+
+After measuring one can evaluate the impact of a hot loop. When working with peripheral drivers one usually looks at the time 
+it took for the hot loop to finish. This is the amount of time the CPU thread was blocked and unable to do other possibly important work.
+Unmitigated blocking hot loops raise the CPU usage and can bring the program to a standstill. In certain cases where the peripheral hardware
+is inconsistent or unstable it can freeze your computer.
+
+One mitigates hot loop effects by yielding the processor inside the hot loop and also setting a maximum number
+of times to retry the hot loop before "giving up" and returning an error. The latter rule comes from [NASA's power of 10 rulebook](https://en.m.wikipedia.org/wiki/The_Power_of_10:_Rules_for_Developing_Safety-Critical_Code): *"All loops must have fixed bounds. This prevents runaway code."*. A good number of retries to use is x2 the number of retries measured, and as another good rule of thumb: never retry less than 10 times if the retry operation is fast.
+Remember the number of retries performed will vary from CPU to CPU since some CPUs are faster. When measuring use the highest communication bitrate for the peripheral to get the best case scenario.
+```go
+// Make sure `retries` makes sense. Use a larger number than the maximum typical hotloops done.
+retries := 1000 
+for retries > 0 && !ready() {
+    runtime.Gosched() // For short hot loops around <1ms
+    retries--
+}
+if retries <= 0 {
+    return errFailedReady
+}
+
+for retries > 0 && !longready() {
+    time.Sleep(typicalLongDuration/5)
+    retries--
+}
+if retries <= 0 {
+    return errFailedReady
+}
+
+// Very friendly to CPU mitigation. We sleep for the typical duration
+// and then start the hot loop.
+// This avoids using the CPU during the time the peripheral is almost certainly not ready.
+time.Sleep(reallyLongDuration)
+for retries > 0 && !reallyLongReady() {
+    time.Sleep(reallyLongDuration/10)
+    retries--
+}
+if retries <= 0 {
+    return errFailedReady
+}
+```
+Note the retry check is in front of the hot loop check in the `for` statement condition: this is for a reason! If not ordered that way then maybe the hot loop check passes but retry fails resulting in a zero retry and a returned error even though the check passed.
+
+## Miscellaneous tips
+### Consolidate I/O into as few dynamic calls as possible
+
+Consider the code below, it does some configuration over an SPI bus and a pin which apparently selects if SPI bytes are data or commands.
+```go
+func (d *Device) Configure(cfg Config) {
+    d.Command(CONFIG_BYTE)
+    d.Data(0x01)
+    d.Data(0x02)
+    d.Data(0x03)
+    d.Data(0x04)
+    d.Data(0x05)
+}
+
+func (d *Device) Data(data uint8) {
+    d.pinData(true)
+    d.spi.Tx([]byte{data}, nil)
+}
+
+func (d *Device) Command(cmd uint8) {
+    d.pinData(false)
+    d.spi.Tx([]byte{cmd}, nil)
+}
+```
+
+Note the string of `d.Data` calls, they all do two I/O operations: turn the data pin on and send a single byte over SPI.
+Below are some problems that can be solved with this approach regarding I/O overhead:
+- Successive `Data` calls turn a pin on that has remained on since last `Data` call
+- Every call of Data does a dynamic call to the SPI `Tx` method
+
+If we are aware of how a `SPI` bus works then we'll know we can concatenate all the single byte `Tx` calls into a single multi-byte `Tx` call.
+
+```go
+func (d *Device) Configure(cfg Config) {
+    d.Command(CONFIG_BYTE)
+    d.Data(0x01, 0x02, 0x03, 0x04, 0x05)
+}
+func (d *Device) Data(data ...byte) {
+    d.pinData(true)
+    d.spi.Tx(data, nil)
+}
+```
+The above code is equivalent in functionality. One may worry we are not calling `d.pinData(true)` between bytes sent over SPI until one realizes calling `d.pinData(true)` after the first call is completely inneffective. Once a pin turns on it stays that way until it is turned off with `d.pinData(false)`.
+
+To get the gold star though we'd want to eliminate heap allocations. Since `Data` may receive thousands of bytes at a time in some cases we define a helper method:
+
+```go
+func (d *Device) Configure(cfg Config) {
+    d.Command(CONFIG_BYTE)
+    d.dataShort(0x01, 0x02, 0x03, 0x04, 0x05)
+}
+func (d *Device) dataShort(data ...byte) {
+    n := copy(d.buf[:], data) // Buf is a static array that is the max size of calls performed by the library internally.
+    d.Data(d.buf[:n])
+}
+func (d *Device) Data(data []byte) {
+    d.pinData(true)
+    d.spi.Tx(data, nil)
+}
+func (d *Device) Command(cmd uint8) {
+    d.pinData(false)
+    d.buf[0] = cmd
+    d.spi.Tx(d.buf[:1], nil)
+}
+```
\ No newline at end of file
diff --git a/content/docs/guides/embedded/_index.md b/content/docs/guides/embedded/_index.md
new file mode 100644
index 00000000..e8138c53
--- /dev/null
+++ b/content/docs/guides/embedded/_index.md
@@ -0,0 +1,7 @@
+---
+title: "Embedded"
+weight: 2
+description: >
+  TinyGo can compile code that can run on even very small microcontrollers.
+---
+
diff --git a/content/docs/guides/embedded/resources.md b/content/docs/guides/embedded/resources.md
new file mode 100644
index 00000000..459755bb
--- /dev/null
+++ b/content/docs/guides/embedded/resources.md
@@ -0,0 +1,103 @@
+---
+title: "Resources"
+weight: 4
+description: |
+    Resources for using TinyGo for embedded development
+---
+
+Here are some of the "official" packages and resources in the TinyGo ecosystem that you can use for creating embedded programs.
+
+[I want to use sensors connected to my device](#sensors)
+
+[I want to use a display connected to my device](#displays)
+
+[I want to make a wireless connection with my device](#wireless)
+
+[I want to store data on my device](#data-storage)
+
+There are also other great resources in the community. You can find some of them in the "Awesome TinyGo" repository:
+
+https://github.com/tinygo-org/awesome-tinygo
+
+
+## Sensors
+
+Check out the TinyGo Drivers repository for many different kinds of sensors that you can use from your TinyGo programs:
+
+https://github.com/tinygo-org/drivers
+
+
+## Displays
+
+There are a number of displays you can connect via SPI or parallel interfaces and then use from your TinyGo programs.
+
+See the TinyGo Drivers repository for some of the supported display devices:
+
+https://github.com/tinygo-org/drivers
+
+### I want to draw some graphics on my display
+
+Check out the TinyDraw repo:
+
+https://github.com/tinygo-org/tinydraw
+
+### I want to show some text on my display
+
+Take a look at the TinyFont repo:
+
+https://github.com/tinygo-org/tinyfont
+
+### I want to use the display as a terminal interface
+
+See the TinyTerm repo:
+
+https://github.com/tinygo-org/tinyterm
+
+
+## Wireless
+
+### I want to use Bluetooth
+
+Check out the TinyGo Bluetooth repository:
+
+https://github.com/tinygo-org/bluetooth
+
+### I want to use WiFi
+
+Check out the TinyGo Drivers repository for some of the WiFi co-processors that you can use from your TinyGo programs:
+
+https://github.com/tinygo-org/drivers
+
+### I want to use LoRa
+
+Check out the TinyGo Drivers repository for some of the LoRa co-processors that you can use from your TinyGo programs:
+
+https://github.com/tinygo-org/drivers
+
+
+## Data Storage
+
+### I want to store data files on the device
+
+Take a look at the TinyFS repository:
+
+https://github.com/tinygo-org/tinyfs
+
+### I want to use the internal Flash memory on my device
+
+See the TinyGo Drivers repository:
+
+https://github.com/tinygo-org/drivers
+
+### I want to use external Flash memory with my device
+
+See the TinyGo Drivers repository:
+
+https://github.com/tinygo-org/drivers
+
+### I want to use an SD card with my device
+
+See the TinyGo Drivers repository:
+
+https://github.com/tinygo-org/drivers
+
diff --git a/content/ide-integration/_index.md b/content/docs/guides/ide-integration/_index.md
similarity index 55%
rename from content/ide-integration/_index.md
rename to content/docs/guides/ide-integration/_index.md
index cbf00eb1..58be5549 100644
--- a/content/ide-integration/_index.md
+++ b/content/docs/guides/ide-integration/_index.md
@@ -1,6 +1,8 @@
 ---
 title: "IDE Integration"
 weight: 8
+description: |
+  TinyGo has some IDE support. This is how you can configure your IDE to recognize the machine package.
 ---
 
 IDEs need to have certain environment variables set before they work with TinyGo: `GOROOT` and `GOFLAGS`. You can determine the correct values from the `tinygo info` command (starting with TinyGo 0.15).
@@ -24,49 +26,14 @@ cached GOROOT:     /home/user/.cache/tinygo/goroot-go1.14-f930d5b5f36579e8cbd1c1
 
 Now you need to configure your IDE with these values.
 
-### Visual Studio Code
-
-In VS Code, you can edit the file `.vscode/settings.json` in the root of your project. If the `.vscode` directory does not yet exist, create it. It's a normal JSON file where you need to set the `go.toolsEnvVars` property. An example file (again, using the above configuration) is the following:
-
-```json
-{
-    "go.toolsEnvVars": {
-        "GOROOT": "/home/user/.cache/tinygo/goroot-go1.14-f930d5b5f36579e8cbd1c139012b3d702281417fb6bdf67303c4697195b9ef1f-syscall",
-        "GOFLAGS": "-tags=cortexm,baremetal,linux,arm,nrf51822,nrf51,nrf,microbit,tinygo,gc.conservative,scheduler.tasks"
-    }
-}
-```
-
-After creating or modifying this file, you will likely need to restart VS Code to apply these settings.
-
-Alternatively, there is a [VSCode addon](https://marketplace.visualstudio.com/items?itemName=tinygo.vscode-tinygo) that will create these settings for you.
-
-### Other IDEs
-
-Other IDEs will likely need a different setup. You can try starting them with these environment variables set in your shell or configuring these environment variables somewhere in your Go language server settings.
-
-As an example, this is an alternative way to start VS Code with the settings above (using `bash`):
-
-```
-GOROOT=/home/user/.cache/tinygo/goroot-go1.14-f930d5b5f36579e8cbd1c139012b3d702281417fb6bdf67303c4697195b9ef1f-syscall GOFLAGS=-tags=cortexm,baremetal,linux,arm,nrf51822,nrf51,nrf,microbit,tinygo,gc.conservative,scheduler.tasks code
-```
-
 ### Using tinygo-edit
 
-There is a CLI tool called [tinygo-edit](https://github.com/sago35/tinygo-edit) you can use it to Gather the needed build flags and starting the editor using the correct environment variables. Using the CLI you don't need to do the steps manualy.
+There is a CLI tool called [tinygo-edit](https://github.com/sago35/tinygo-edit) you can use it to Gather the needed build flags and starting the editor using the correct environment variables. Using the CLI you don't need to do the steps manually.
 
 ### Using an alias
 
 Another alternative to automate the process of fetching the needed environment variables and starting your editor, you could also create an alias.
 
-#### Ubuntu Example using vscode
-
-```bash
-export VISUAL=code
-export EDITOR="$VISUAL"
-alias startTinyGoArduino="GOOS=linux GOARCH=arm GOFLAGS=-tags=$(tinygo info arduino|grep 'build tags'|awk -F: '{print $2}' | sed -e 's/^[[:space:]]*//'|sed -e 's/[[:space:]]/,/g') $EDITOR"
-```
-
 ## TinyGo Drivers
 
 There are already lot's of drivers for common hardware. See [this](https://github.com/tinygo-org/drivers) for more information.
diff --git a/content/docs/guides/ide-integration/intellij.md b/content/docs/guides/ide-integration/intellij.md
new file mode 100644
index 00000000..55de41c9
--- /dev/null
+++ b/content/docs/guides/ide-integration/intellij.md
@@ -0,0 +1,8 @@
+---
+title: "IntelliJ IDEA"
+weight: 10
+---
+
+You can install [TinyGo plugin](https://plugins.jetbrains.com/plugin/16915-tinygo) for IntelliJ IDEA Ultimate or GoLand with the version 2021.1.2 or higher. It provides an easy way of creating a new project, runs TinyGo applications and code inspections.
+
+All features are described on the [blog post](https://blog.jetbrains.com/go/2021/06/02/tinygo-for-tiny-applications-discover-a-new-plugin-for-goland/).
diff --git a/content/docs/guides/ide-integration/other.md b/content/docs/guides/ide-integration/other.md
new file mode 100644
index 00000000..032e1b60
--- /dev/null
+++ b/content/docs/guides/ide-integration/other.md
@@ -0,0 +1,6 @@
+---
+title: "Other IDEs"
+weight: 10
+---
+
+Other IDEs will likely need a different setup. You can try starting them with these environment variables set in your shell or configuring these environment variables somewhere in your Go language server settings.
diff --git a/content/docs/guides/ide-integration/vim-neovim.md b/content/docs/guides/ide-integration/vim-neovim.md
new file mode 100644
index 00000000..1f8862b2
--- /dev/null
+++ b/content/docs/guides/ide-integration/vim-neovim.md
@@ -0,0 +1,22 @@
+---
+title: "Vim and Neovim"
+weight: 9
+---
+
+In Vim and Neovim LSP servers can be configured to offer completions and documentation based on the contents of the file you are editing.
+These LSP servers (i.e. `gopls` in our case) are spawned by Vim and Neovim themselves. This means we must provide them with the appropriate
+environment so that they know where to find the definition of the `machine package`.
+
+This can be done manually before starting Vim or Neovim by running `export` on the shell. However, this can become cumbersome and very
+fast. That is why some available plugins automate the setup by providing a single command you can use to configure the target.
+
+An option would be to use [tinygo.vim](https://github.com/sago35/tinygo.vim). This plugin offers the `:TinygoTarget` command within
+Vim and Neovim to change the target at will. It is written in Vim Script, Vim's builtin scripting language. However, it is compatible
+both with Vim and Neovim. You can find more information on how to install and use it in the project's page linked above.
+
+A second option would be using a Neovim-native plugin: [tinygo.nvim](https://github.com/pcolladosoto/tinygo.nvim). Unlike the previous
+option, this plugin is written entirely in Lua, making it only compatible with Neovim. Through the `:TinyGoSetTarget` command you
+can also configure the current target for the `machine` package. Information on how to install and use it is available on its project
+page, which is also linked above.
+
+At any rate, either plugin offers a complete integration for TinyGo so that you can leverage all the advantages of `gopls`.
diff --git a/content/docs/guides/ide-integration/vscode.md b/content/docs/guides/ide-integration/vscode.md
new file mode 100644
index 00000000..ce84fdc8
--- /dev/null
+++ b/content/docs/guides/ide-integration/vscode.md
@@ -0,0 +1,28 @@
+---
+title: "VS Code"
+weight: 9
+---
+
+In VS Code, you can edit the file `.vscode/settings.json` in the root of your project. If the `.vscode` directory does not yet exist, create it. It's a normal JSON file where you need to set the `go.toolsEnvVars` property. An example file (again, using the above configuration) is the following:
+
+```json
+{
+    "go.toolsEnvVars": {
+        "GOROOT": "/home/user/.cache/tinygo/goroot-go1.14-f930d5b5f36579e8cbd1c139012b3d702281417fb6bdf67303c4697195b9ef1f-syscall",
+        "GOFLAGS": "-tags=cortexm,baremetal,linux,arm,nrf51822,nrf51,nrf,microbit,tinygo,gc.conservative,scheduler.tasks"
+    }
+}
+```
+
+After creating or modifying this file, you will likely need to restart VS Code to apply these settings.
+
+Alternatively, there is a [VSCode addon](https://marketplace.visualstudio.com/items?itemName=tinygo.vscode-tinygo) that will create these settings for you.
+
+
+#### Ubuntu Example using vscode
+
+```bash
+export VISUAL=code
+export EDITOR="$VISUAL"
+alias startTinyGoArduino="GOOS=linux GOARCH=arm GOFLAGS=-tags=$(tinygo info arduino|grep 'build tags'|awk -F: '{print $2}' | sed -e 's/^[[:space:]]*//'|sed -e 's/[[:space:]]/,/g') $EDITOR"
+```
diff --git a/content/linux/_index.md b/content/docs/guides/linux.md
similarity index 85%
rename from content/linux/_index.md
rename to content/docs/guides/linux.md
index b5023de0..cd6e91dd 100644
--- a/content/linux/_index.md
+++ b/content/docs/guides/linux.md
@@ -1,11 +1,10 @@
 ---
-title: "Linux"
-chapter: true
-weight: 5
+title: "Linux support"
+weight: 4
+description: |
+  How to use TinyGo to create normal Linux executables.
 ---
 
-# TinyGo on Linux
-
 TinyGo also lets you compile programs for Linux systems, both 32-bit and 64-bit, on both x86 and ARM architectures.
 
 For cross compiling, you can use `GOOS` and `GOARCH` as usual. For example, you can cross compile the `examples/serial` example from a Linux host to a Raspberry Pi with the following command:
diff --git a/content/docs/guides/macos.md b/content/docs/guides/macos.md
new file mode 100644
index 00000000..7fc241a8
--- /dev/null
+++ b/content/docs/guides/macos.md
@@ -0,0 +1,12 @@
+---
+title: "macOS support"
+weight: 4
+description: |
+  How to use TinyGo to create standard macOS executables.
+---
+
+Using TinyGo you can compile programs for macOS systems.
+
+For cross compiling, you can use `GOOS`. For example, you can cross compile the `examples/serial` example from a Linux host targeting macOS with the following command:
+
+    GOOS=darwin tinygo build -o serial examples/serial
diff --git a/content/docs/guides/optimizing-binaries.md b/content/docs/guides/optimizing-binaries.md
new file mode 100644
index 00000000..ec7a69c9
--- /dev/null
+++ b/content/docs/guides/optimizing-binaries.md
@@ -0,0 +1,68 @@
+---
+title: "Optimizing binaries"
+weight: 11
+description: |
+  How to improve speed or reduce code size for TinyGo programs.
+---
+
+There are various ways TinyGo programs can be optimized for speed, size, or debuggability.
+
+## Optimizing for code size
+
+By default, binaries are already optimized for code size (`-opt=z`, equivalent to `-Oz`, is the default). However, there are various things you can do to improve code size.
+
+### Do not import large packages
+
+You may be tempted to import packages like `fmt` for simple formatted printing. But `fmt` is very large, so unless you absolutely need it, it is recommended to try to avoid it.
+
+In many cases, you can use `println` instead:
+
+```go
+println("2 + 2 =", 2 + 2) // prints: "2 + 2 = 4"
+```
+
+### Remove debug symbols (WebAssembly)
+
+You can omit debug symbols to reduce the size of WebAssembly binaries using the `-no-debug` flag:
+
+    $ tinygo build -o test.wasm examples/serial && ls -lh test.wasm
+    -rwxrwxr-x 1 ayke ayke 93K  4 sep 17:04 test.wasm
+    
+    $ tinygo build -o test.wasm -no-debug examples/serial && ls -lh test.wasm
+    -rwxrwxr-x 1 ayke ayke 30K  4 sep 17:04 test.wasm
+
+As you can see, debug information is ⅔ of this binary so removing it helps a lot!
+
+This may also help on desktop systems (Windows, macOS, Linux) if you want small binaries, but you can also simply use the `strip` utility. It does not have an effect on microcontrollers (Arduino etc) because the debug information is not stored in the firmware image.
+
+### Other options
+
+You can also try the following:
+
+  - Disable goroutines using `-scheduler=none`. It will remove support for the `go` keyword and some related features.
+  - Don't print panic messages using `-panic=trap`. This will make debugging harder but it can cut down on code size.
+  - Disable the GC using `-gc=leaking` (for very short-lived programs only).
+  - Try `-opt=s` and `-opt=2`. While these options normally increase binary size (for higher performance), in rare cases they will actually reduce binary size.
+
+With all these flags applied, the binary is reduced from 93K to just 1.6K!
+
+    $ tinygo build -o test.wasm -no-debug -panic=trap -scheduler=none -gc=leaking examples/serial && ls -lh test.wasm
+    -rwxrwxr-x 1 ayke ayke 1,6K  4 sep 17:30 test.wasm
+
+## Optimize for speed
+
+Flags you can try, roughly in order of importance:
+
+  - `-opt=2` to optimize for speed over code size. The default is to optimize for size (`-opt=z`).
+  - `-gc=leaking` disables the garbage collector, which can sometimes have a large effect (especially on WebAssembly). Of course, memory will never be freed so this is only appropriate for very short-lived programs.
+  - `-scheduler=none` disables the scheduler. This won't usually have much of an effect, but might help on WebAssembly because WebAssembly doesn't have native support for stack switching ([yet](https://github.com/WebAssembly/stack-switching)).
+  - `-panic=trap` might help a little bit by removing some code.
+
+
+## Optimize for debugging
+
+While TinyGo binaries by default include debug information, they are also heavily optimized for size. Therefore, debugging might be difficult by default. You can try the following to make it easier:
+
+  - `-opt=1` will disable some optimization passes which can make debugging somewhat easier.
+  - `-opt=0` will remove most optimization passes, which should make debugging even easier than `-opt=1`. However, because so many passes are disabled, some programs don't work well anymore.
+  - Of course, don't use `-no-debug`.
diff --git a/content/docs/guides/tinygo-flash-errors.md b/content/docs/guides/tinygo-flash-errors.md
new file mode 100644
index 00000000..8dc4cefd
--- /dev/null
+++ b/content/docs/guides/tinygo-flash-errors.md
@@ -0,0 +1,104 @@
+---
+title: "Tinygo flash errors"
+weight: 11
+description: |
+  Solving common problems when flashing your first TinyGo program.
+---
+
+Flashing to a port may be a source of pain with a unconfigured computer. Here are some common problems when trying to get your first program on a device.
+
+* [Unable to locate any volume (Linux)](#unable-to-locate-any-volume-inux)
+* [Serial port permission problems (Linux)](#permission-denied-linux)
+
+### Unable to locate any volume (Linux)
+
+This error happens with devices such as the Pi Pico (and the Pico-W) which use the UF2 protocol for flashing programs.  With this protocol, the device 
+emulates a USB block storage device that can be mounted. When you copy a properly formatted flash image onto this virtual disk drive, the side effect
+is to flash that image onto the device.
+
+For the pico with `target=pico`, `tinygo` expects to see this device in the current directory under the name `RPI-RP2`. If this volume is is not found,
+you will get an error message like this:
+```bash
+failed to flash /tmp/tinygo173718394/main.uf2: unable to locate any volume: [RPI-RP2]
+```
+
+To fix this problem, you need to mount the volume after restarting the Pico while holding down the `BOOTSEL` button. You can do this manually, but it
+is better to edit the `/etc/fstab` file to allow users to do this themselves. You can do this by adding a line like this to `/etc/fstab`:
+```bash
+LABEL=RPI-RP2  /path/to/volume/RPI-RP2  vfat	defaults,umask=000,users
+```
+where you replace `/path/to/volume` with a pathname of your choosing. It is common for this to be put in your home directory or in a system standard
+place such as `/mnt/RPI-RP2`, but it can also be in the directory where you expect to run `tinygo`. You will also need to create a directory with the path 
+`/path/to/volume/RPI-RP2`. Once you have done this and after restarting the Pico in
+`BOOTSEL` mode, you should be able to see the Pico's block device using this command
+```bash
+lsblock -f
+```
+On a typical system, the Pico will show up like this
+```bash
+sda                                                                                  
+└─sda1      vfat     RPI-RP2     000A-9BF3
+```
+you can mount the Pico using this command:
+```bash
+mount /path/to/volume/RPI-RP2
+```
+You can verify that this has worked using this command:
+```bash
+mount | grep RPI
+```
+If you get output that looks like this, you have succeeded in mounting the volume
+```bash
+/dev/sda1 on /mnt/RPI-RP2 type vfat (rw,nosuid,...lots more stuff...)
+```
+If you mounted your Pico someplace other than in your development directory, you should create a symbolic
+link to the mounted volume in the directory where you plan to run `tinygo`. This can be done using
+```bash
+ln -s /mnt/RPI-RP2/
+```
+Note that editing `/etc/fstab`, creating the mount point directory with `mkdir` and creating your symbolic
+link all only need to be done once. During development, you will only need to do the `mount` command
+after restarting the Pico. After flashing the Pico, it is good practice to unmount the drive using the command
+```bash
+umount /path/to/volume/RPI-RP2
+```
+### Permission Denied (Linux)
+
+This error is usually encountered when flashing your first program, here's a typical error:
+```
+avrdude: ser_open(): can't open device "/dev/ttyACM0": Permission denied
+```
+
+The above error may be followed by `ioctl` errors too.
+
+To fix this we must make sure our user is included in the group with access to serial ports. On ubuntu and Debian this is the **dialout** group. The equivalent group on Arch Linux based distributions is **uucp**.
+
+First we can check if we are not already part of the `dialout` group:
+
+```shell
+groups
+```
+The output should look something like `youruser adm cdrom sudo dip plugdev lpadmin lxd sambashare`. If dialout is not present in the groups we can add ourselves to it with the following command:
+
+```shell
+sudo usermod -aG dialout $(whoami)
+```
+This will add our current user to dialout group. **Log out and log in again to complete the procedure**. You should now be able to flash to your device. 
+
+As a last resort if this does not work you can try to modify the permissions with `chmod`. For the error above we may try `sudo chmod a+rw /dev/ttyACM0` where `/dev/ttyACM0` is the serial port we are trying to flash to.
+
+### Disable "not ejected safely" notification (Mac)
+
+Some boards are flashed by copying over `.uf2` file to the board mounted as Mass Storage Device.  
+Upon successful flashing, the board reboots and this looks to the OS as the board was _unsafely_ ejected (yanked out by user), so OS warns with a notification that has to be acknowledged (it does not disappear itself).  
+This can become annoying very quickly during intense flash-run-debug sessions. Thankfully, it is possible to disable this behaviour.  
+
+In terminal, execute following and **restart the system**:
+```
+sudo defaults write /Library/Preferences/SystemConfiguration/com.apple.DiskArbitration.diskarbitrationd.plist DADisableEjectNotification -bool YES && sudo pkill diskarbitrationd
+```
+
+Revert to the default behaviour:
+```
+sudo defaults delete /Library/Preferences/SystemConfiguration/com.apple.DiskArbitration.diskarbitrationd.plist DADisableEjectNotification && sudo pkill diskarbitrationd
+```
diff --git a/content/docs/guides/tips-n-tricks.md b/content/docs/guides/tips-n-tricks.md
new file mode 100644
index 00000000..2d9aa4f7
--- /dev/null
+++ b/content/docs/guides/tips-n-tricks.md
@@ -0,0 +1,97 @@
+---
+title: "Tips, Tricks and Gotchas"
+weight: 4
+description: |
+  Tips and tricks for small places.
+  How to write efficient embedded code and avoid common mistakes.
+---
+
+## Ensure Concurrency
+
+In many cases (especially on microcontrollers), TinyGo is running on a single core with only [cooperative scheduling](https://en.wikipedia.org/wiki/Cooperative_multitasking). This means that a goroutine that never does IO or other blocking calls (f.ex. `time.Sleep()`) will lock the single available thread only for itself and never allow other goroutines to execute. In such cases, you can use `runtime.Gosched()` as a workaround.
+
+```
+package main
+
+import (
+    "fmt"
+    "time"
+    "sync/atomic"
+    "runtime"
+)
+
+func main() {
+
+    var ops uint64 = 0
+    for i := 0; i < 50; i++ {
+        go func() {
+            for {
+                atomic.AddUint64(&ops, 1)
+                runtime.Gosched()
+            }
+        }()
+    }
+
+    time.Sleep(time.Second)
+
+    opsFinal := atomic.LoadUint64(&ops)
+    fmt.Println("ops:", opsFinal)
+}
+```
+
+## Save Memory
+
+Use the fact [slices are descriptors of array segments](https://go.dev/blog/slices-intro#slice-internals) to save memory and avoid unnecessary allocations.
+Allocate once an array of maximum size you ever need and slice it in your methods to the required sizes as you go.
+
+```
+type MyType struct {
+    // ...other fields
+    buf [6]byte
+}
+
+func (t *MyType) SomeMethod() {
+    tmpBuf := t.buf[:2] // this method needs a buffer of size 2
+    // ... use the buffer
+}
+```
+
+You may even find yourself having two or more slices pointing at different regions of the same array simultaneously, if you are careful.
+
+```
+buf1 := t.buf[:2]
+buf2 := t.buf[2:6]
+```
+
+For more recipes on how to avoid or minimize allocations while working with slices, please see [additional tricks](https://github.com/golang/go/wiki/SliceTricks#additional-tricks) section of [slice tricks](https://github.com/golang/go/wiki/SliceTricks) page.
+
+Familiarize yourself with [heap allocation concept]({{<ref "../concepts/compiler-internals/heap-allocation.md">}}) and use it to your advantage.
+
+## How to set build-time variables
+
+You might have some specific value that you want to set for a variable at build-time. For example, you might want to preset a serial number, or set the WiFi access point SSID that you want your device to connect to, or set the version of the code being built.
+
+This can be done using the `tinygo build` command `-ldflags` flag like this:
+
+`tinygo build -ldflags="-X 'main.version=1.0.0'" -target pyportal .`
+
+In your TinyGo program, the variable of the same package name/variable name will have its value set using the value passed in the `-ldflags` flag. Most commonly this will use the scope of the `main` package.
+
+```go
+package main
+
+var version string
+
+func main() {
+	println("the version is", version)
+}
+```
+
+One important thing to note is that you cannot use a default value in your code if you want to be able to set that value using `-ldflags`. If you set the variable to a default value, then the value you pass using `ldflags` will be ignored. The value of the `version` variable in this code excerpt would **not** be changed by for this reason:
+
+```go
+// will not be changed by using ldflags
+var version = "default value"
+```
+
+Another important thing to note is that the values passed in could end up cached on the machine used to build the binary, for example in `~/.cache/tinygo/thinlto/`. Because this feature is often used to pass in secrets, you will want to clear this cache as needed based on the security needs of your application.
diff --git a/content/docs/guides/webassembly/_index.md b/content/docs/guides/webassembly/_index.md
new file mode 100644
index 00000000..d3aa74ca
--- /dev/null
+++ b/content/docs/guides/webassembly/_index.md
@@ -0,0 +1,7 @@
+---
+title: "WebAssembly"
+weight: 2
+description: >
+  TinyGo is very useful for compiling programs both for use in browsers (WASM) as well as for use on servers and other edge devices (WASI).
+---
+
diff --git a/content/docs/guides/webassembly/resources.md b/content/docs/guides/webassembly/resources.md
new file mode 100644
index 00000000..9d34b425
--- /dev/null
+++ b/content/docs/guides/webassembly/resources.md
@@ -0,0 +1,32 @@
+---
+title: "Additional Resources"
+weight: 4
+description: |
+  Additional Resources for using TinyGo with WASM/WASI
+---
+
+Here are a few resources for helping learn more about using TinyGo with WebAssembly.
+
+**Wasm By Example**
+https://wasmbyexample.dev/
+
+**Are We Wasm Yet ? - Part 1**
+https://elewis.dev/are-we-wasm-yet-part-1
+
+**Are We Wasm Yet ? - Part 2**
+https://elewis.dev/are-we-wasm-yet-part-2
+
+**Writing a WebAssembly Service in TinyGo for Wagi and Spin**
+https://www.fermyon.com/blog/tinygo-webassembly-favicon-server
+
+**wazero - TinyGo**
+https://wazero.io/languages/tinygo/
+
+**WasmEdge Runtime - Go**
+https://wasmedge.org/book/en/write_wasm/go.html
+
+**WASI and Node.js**
+https://k33g.hashnode.dev/series/wasi-nodejs
+
+**Wazero, first steps**
+https://k33g.hashnode.dev/series/wazero-first-steps
diff --git a/content/docs/guides/webassembly/wasi.md b/content/docs/guides/webassembly/wasi.md
new file mode 100644
index 00000000..007af232
--- /dev/null
+++ b/content/docs/guides/webassembly/wasi.md
@@ -0,0 +1,32 @@
+---
+title: "Using WASI"
+weight: 3
+description: |
+  How to use TinyGo with the WebAssembly System Interface (WASI).
+---
+
+TinyGo is very useful for compiling programs for use on servers and other edge devices (WASI).
+
+TinyGo programs can run in [Extism](https://github.com/extism/extism), [Fastly Compute@Edge](https://developer.fastly.com/learning/compute/go/), [Fermyon Spin](https://developer.fermyon.com/spin/go-components), [tau](https://github.com/taubyte/tau), [wazero](https://wazero.io/languages/tinygo/) and many other WebAssembly runtimes.
+
+Both WASI Preview 1 (wasip1) and WASI Preview 2 (wasip2) are currently supported.
+
+Here is a small TinyGo program for use within a WASI host application:
+
+```go
+package main
+
+//go:wasmimport yourmodulename add
+func add(x, y uint32) uint32 {
+	return x + y
+}
+
+// main is required for the `wasip1` target, even if it isn't used.
+func main() {}
+```
+
+To compile the above TinyGo program for use on any WASI runtime:
+
+```shell
+GOOS=wasip1 GOARCH=wasm tinygo build -o main.wasm main.go
+```
diff --git a/content/webassembly/webassembly.md b/content/docs/guides/webassembly/wasm.md
similarity index 83%
rename from content/webassembly/webassembly.md
rename to content/docs/guides/webassembly/wasm.md
index 674289ae..358c4738 100644
--- a/content/webassembly/webassembly.md
+++ b/content/docs/guides/webassembly/wasm.md
@@ -1,6 +1,8 @@
 ---
-title: "Using WebAssembly"
+title: "Using WASM"
 weight: 3
+description: |
+  How to call WebAssembly from JavaScript in a browser.
 ---
 
 You can call a JavaScript function from Go and call a Go function from WebAssembly:
@@ -14,12 +16,15 @@ func main() {
 }
 
 // This function is imported from JavaScript, as it doesn't define a body.
-// You should define a function named 'main.add' in the WebAssembly 'env'
+// You should define a function named 'add' in the WebAssembly 'env'
 // module from JavaScript.
+//
+//export add
 func add(x, y int) int
 
 // This function is exported to JavaScript, so can be called using
 // exports.multiply() in JavaScript.
+//
 //export multiply
 func multiply(x, y int) int {
     return x * y;
@@ -30,8 +35,9 @@ Related JavaScript would look something like this:
 
 ```javascript
 // Providing the environment object, used in WebAssembly.instantiateStreaming.
-env: {
-    'main.add': function(x, y) {
+// This part goes after "const go = new Go();" declaration.
+go.importObject.env = {
+    'add': function(x, y) {
         return x + y
     }
     // ... other functions
@@ -49,7 +55,7 @@ implementation of WebAssembly.
 If you have `tinygo` installed, it's as simple as providing the correct target:
 
 ```
-tinygo build -o wasm.wasm -target wasm ./main.go
+GOOS=js GOARCH=wasm tinygo build -o wasm.wasm ./main.go
 ```
 
 If you're using the docker image, you need to mount your workspace into the image.
@@ -57,16 +63,16 @@ Note the `--no-debug` flag, which reduces the size of the final binary by removi
 debug symbols from the output. Also note that you must change the path to your Wasm file from `/go/src/github.com/myuser/myrepo/wasm-main.go` to whatever the actual path to your file is:
 
 ```
-docker run -v $GOPATH:/go -e "GOPATH=/go" tinygo/tinygo:0.16.0 tinygo build -o /go/src/github.com/myuser/myrepo/wasm.wasm -target wasm --no-debug /go/src/github.com/myuser/myrepo/wasm-main.go
+docker run -v $GOPATH:/go -e "GOPATH=/go" tinygo/tinygo:0.39.0 GOOS=js GOARCH=wasm tinygo build -o /go/src/github.com/myuser/myrepo/wasm.wasm --no-debug /go/src/github.com/myuser/myrepo/wasm-main.go
 ```
 
-Make sure you copy `wasm_exec.js` to your runtime environment:
+Make sure you copy `wasm_exec.js` to your runtime environment (always available at `$(tinygo env TINYGOROOT)/targets/wasm_exec.js`):
 
 ```
-docker run -v $GOPATH:/go -e "GOPATH=/go" tinygo/tinygo:0.16.0 /bin/bash -c "cp /usr/local/tinygo/targets/wasm_exec.js /go/src/github.com/myuser/myrepo/
+docker run -v $GOPATH:/go -e "GOPATH=/go" tinygo/tinygo:0.39.0 /bin/bash -c "cp /usr/local/tinygo/targets/wasm_exec.js /go/src/github.com/myuser/myrepo/
 ```
 
-More complete examples are provided in the [wasm examples](https://github.com/tinygo-org/tinygo/tree/master/src/examples/wasm).
+More complete examples are provided in the [wasm examples](https://github.com/tinygo-org/tinygo/tree/release/src/examples/wasm).
 
 ## How it works
 
@@ -131,7 +137,8 @@ func main() {
 			resp.Header().Set("content-type", "application/wasm")
 		}
 		fs.ServeHTTP(resp, req)
-	}))}
+	}))
+}
 ```
 
 This simple server serves anything inside the `./html` directory on port
diff --git a/content/docs/guides/windows.md b/content/docs/guides/windows.md
new file mode 100644
index 00000000..2eb9e014
--- /dev/null
+++ b/content/docs/guides/windows.md
@@ -0,0 +1,12 @@
+---
+title: "Windows support"
+weight: 4
+description: |
+  How to use TinyGo to create standard Windows executables.
+---
+
+TinyGo also lets you compile programs for Windows systems.
+
+For cross compiling, you can use `GOOS` and `GOARCH` as usual. For example, you can cross compile the `examples/serial` example from a Linux host targeting Windows with the following command:
+
+    GOOS=windows tinygo build -o serial.exe examples/serial
diff --git a/content/docs/reference/_index.md b/content/docs/reference/_index.md
new file mode 100644
index 00000000..e29cb372
--- /dev/null
+++ b/content/docs/reference/_index.md
@@ -0,0 +1,7 @@
+---
+title: "Reference"
+linkTitle: "Reference"
+weight: 4
+description: >
+  Reference guides are technical descriptions about TinyGo and how to operate it.
+---
\ No newline at end of file
diff --git a/content/docs/reference/devices/_index.md b/content/docs/reference/devices/_index.md
new file mode 100644
index 00000000..65182882
--- /dev/null
+++ b/content/docs/reference/devices/_index.md
@@ -0,0 +1,125 @@
+---
+title: "Devices"
+chapter: true
+weight: 4
+description: |
+  Sensors and displays that are supported by TinyGo.
+---
+
+TinyGo has support for many different devices and sensors such as digital accelerometers, OLED displays, WiFi adaptors, and more.
+
+Drivers are packages designed to make it easier to use these devices from your own TinyGo programs.
+
+All of these drivers can be found in the TinyGo Drivers repository located at [https://github.com/tinygo-org/drivers/](https://github.com/tinygo-org/drivers/)
+
+The following 102 devices are supported.
+
+| Device Name                                                             | Datasheet   | Interface Type |
+|-------------------------------------------------------------------------|-------------|----------------|
+| [4x4 Membrane Keypad](https://pkg.go.dev/tinygo.org/x/drivers/keypad4x4) | [datasheet](https://cdn.sparkfun.com/assets/f/f/a/5/0/DS-16038.pdf) | GPIO |
+| [ADT7410 I2C Temperature Sensor](https://pkg.go.dev/tinygo.org/x/drivers/adt7410) | [datasheet](https://www.analog.com/media/en/technical-documentation/data-sheets/ADT7410.pdf) | I2C |
+| [ADXL345 accelerometer](https://pkg.go.dev/tinygo.org/x/drivers/adxl345) | [datasheet](http://www.analog.com/media/en/technical-documentation/data-sheets/ADXL345.pdf) | I2C |
+| [AHT20 I2C Temperature and Humidity Sensor](https://pkg.go.dev/tinygo.org/x/drivers/aht20) | [datasheet](http://www.aosong.com/userfiles/files/media/AHT20%20%E8%8B%B1%E6%96%87%E7%89%88%E8%AF%B4%E6%98%8E%E4%B9%A6%20A0%2020201222.pdf) | I2C |
+| [AMG88xx 8x8 Thermal camera sensor](https://pkg.go.dev/tinygo.org/x/drivers/amg88xx) | [datasheet](https://cdn-learn.adafruit.com/assets/assets/000/043/261/original/Grid-EYE_SPECIFICATIONS%28Reference%29.pdf) | I2C |
+| [APA102 RGB LED](https://pkg.go.dev/tinygo.org/x/drivers/apa102) | [datasheet](https://cdn-shop.adafruit.com/product-files/2343/APA102C.pdf) | SPI |
+| [APDS9960 Digital proximity, ambient light, RGB and gesture sensor](https://pkg.go.dev/tinygo.org/x/drivers/apds9960) | [datasheet](https://cdn.sparkfun.com/assets/learn_tutorials/3/2/1/Avago-APDS-9960-datasheet.pdf) | I2C |
+| [AS5600 / AS5601](https://pkg.go.dev/tinygo.org/x/drivers/as560x) [on-axis magnetic rotary position sensors]()(https://ams.com/angle-position-on-axis) | [datasheet](https://ams.com/documents/20143/36005/AS5600_DS000365_5-00.pdf) | I2C |
+| [AT24CX 2-wire serial EEPROM](https://pkg.go.dev/tinygo.org/x/drivers/at24cx) | [datasheet](https://www.openimpulse.com/blog/wp-content/uploads/wpsc/downloadables/24C32-Datasheet.pdf) | I2C |
+| [AXP192 single Cell Li-Battery and Power System Management](https://pkg.go.dev/tinygo.org/x/drivers/axp192) | [datasheet](https://github.com/m5stack/M5-Schematic/blob/master/Core/AXP192%20Datasheet_v1.1_en_draft_2211.pdf) | I2C |
+| [BBC micro:bit LED matrix](https://pkg.go.dev/tinygo.org/x/drivers/microbitmatrix) | [datasheet](https://github.com/bbcmicrobit/hardware/blob/master/SCH_BBC-Microbit_V1.3B.pdf) | GPIO |
+| [BH1750 ambient light sensor](https://pkg.go.dev/tinygo.org/x/drivers/bh1750) | [datasheet](https://www.mouser.com/ds/2/348/bh1750fvi-e-186247.pdf) | I2C |
+| [BlinkM RGB LED](https://pkg.go.dev/tinygo.org/x/drivers/blinkm) | [datasheet](http://thingm.com/fileadmin/thingm/downloads/BlinkM_datasheet.pdf) | I2C |
+| [BMA42X triaxial acceleration sensor](https://pkg.go.dev/tinygo.org/x/drivers/bma427) | [datasheet](https://files.pine64.org/doc/datasheet/pinetime/BST-BMA421-FL000.pdf) | I2C |
+| [BME280 humidity/pressure sensor](https://pkg.go.dev/tinygo.org/x/drivers/bme280) | [datasheet](https://cdn-shop.adafruit.com/datasheets/BST-BME280_DS001-10.pdf) | I2C |
+| [BMI160 accelerometer/gyroscope](https://pkg.go.dev/tinygo.org/x/drivers/bmi160) | [datasheet](https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmi160-ds000.pdf) | SPI |
+| [BMP180 barometer](https://pkg.go.dev/tinygo.org/x/drivers/bmp180) | [datasheet](https://cdn-shop.adafruit.com/datasheets/BST-BMP180-DS000-09.pdf) | I2C |
+| [BMP280 temperature/barometer](https://pkg.go.dev/tinygo.org/x/drivers/bmp280) | [datasheet](https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp280-ds001.pdf) | I2C |
+| [BMP388 pressure sensor](https://pkg.go.dev/tinygo.org/x/drivers/bmp388) | [datasheet](https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp388-ds001.pdf) | I2C |
+| [Buzzer](https://pkg.go.dev/tinygo.org/x/drivers/buzzer) | [datasheet](https://en.wikipedia.org/wiki/Buzzer#Piezoelectric) | GPIO |
+| [DHTXX thermometer and humidity sensor](https://pkg.go.dev/tinygo.org/x/drivers/dht) | [datasheet](https://cdn-shop.adafruit.com/datasheets/Digital+humidity+and+temperature+sensor+AM2302.pdf) | GPIO |
+| [DS1307 real time clock](https://pkg.go.dev/tinygo.org/x/drivers/ds1307) | [datasheet](https://datasheets.maximintegrated.com/en/ds/DS1307.pdf) | I2C |
+| [DS18B20 digital thermometer](https://pkg.go.dev/tinygo.org/x/drivers/ds18b20) | [datasheet](https://datasheets.maximintegrated.com/en/ds/DS1307.pdf) | I2C |
+| [DS3231 real time clock](https://pkg.go.dev/tinygo.org/x/drivers/ds3231) | [datasheet](https://datasheets.maximintegrated.com/en/ds/DS3231.pdf) | I2C |
+| [ESP32 as WiFi Coprocessor with Arduino nina-fw](https://pkg.go.dev/tinygo.org/x/drivers/wifinina) | [datasheet](https://github.com/arduino/nina-fw) | SPI |
+| [ESP8266/ESP32 AT Command set for WiFi/TCP/UDP](https://pkg.go.dev/tinygo.org/x/drivers/espat) | [datasheet](https://github.com/espressif/esp32-at) | UART |
+| [FT6336 touch controller](https://pkg.go.dev/tinygo.org/x/drivers/ft6336) | [datasheet](https://focuslcds.com/content/FT6236.pdf) | I2C |
+| [GPS module](https://pkg.go.dev/tinygo.org/x/drivers/gps) | [datasheet](https://www.u-blox.com/en/product/neo-6-series) | I2C/UART |
+| [HC-SR04 Ultrasonic distance sensor](https://pkg.go.dev/tinygo.org/x/drivers/hcsr04) | [datasheet](https://cdn.sparkfun.com/datasheets/Sensors/Proximity/HCSR04.pdf) | GPIO |
+| [HD44780 LCD controller](https://pkg.go.dev/tinygo.org/x/drivers/hd44780) | [datasheet](https://www.sparkfun.com/datasheets/LCD/HD44780.pdf) | GPIO/I2C |
+| [HTS221 digital humidity and temperature sensor](https://pkg.go.dev/tinygo.org/x/drivers/hts221) | [datasheet](https://www.st.com/resource/en/datasheet/hts221.pdf) | I2C |
+| [HUB75 RGB led matrix](https://pkg.go.dev/tinygo.org/x/drivers/hub75) | [datasheet](https://cdn-learn.adafruit.com/downloads/pdf/32x16-32x32-rgb-led-matrix.pdf) | SPI |
+| [ILI9341 TFT color display](https://pkg.go.dev/tinygo.org/x/drivers/ili9341) | [datasheet](https://cdn-shop.adafruit.com/datasheets/ILI9341.pdf) | SPI |
+| [INA260 Volt/Amp/Power meter](https://pkg.go.dev/tinygo.org/x/drivers/ina260) | [datasheet](https://www.ti.com/lit/ds/symlink/ina260.pdf) | I2C |
+| [Infrared remote control](https://pkg.go.dev/tinygo.org/x/drivers/irremote) | [datasheet](https://en.wikipedia.org/wiki/Consumer_IR) | GPIO |
+| [IS31FL3731 matrix LED driver](https://pkg.go.dev/tinygo.org/x/drivers/is31fl3731) | [datasheet](https://www.lumissil.com/assets/pdf/core/IS31FL3731_DS.pdf) | I2C |
+| [L293x motor driver](https://pkg.go.dev/tinygo.org/x/drivers/l293x) | [datasheet](https://www.ti.com/lit/ds/symlink/l293d.pdf) | GPIO/PWM |
+| [L9110x motor driver](https://pkg.go.dev/tinygo.org/x/drivers/l9110x) | [datasheet](https://www.elecrow.com/download/datasheet-l9110.pdf) | GPIO/PWM |
+| [LIS2MDL magnetometer](https://pkg.go.dev/tinygo.org/x/drivers/lis2mdl) | [datasheet](https://www.st.com/resource/en/datasheet/lis2mdl.pdf) | I2C |
+| [LIS3DH accelerometer](https://pkg.go.dev/tinygo.org/x/drivers/lis3dh) | [datasheet](https://www.st.com/resource/en/datasheet/lis3dh.pdf) | I2C |
+| [LPS22HB MEMS nano pressure sensor](https://pkg.go.dev/tinygo.org/x/drivers/lps22hb) | [datasheet](https://www.st.com/resource/en/datasheet/dm00140895.pdf) | I2C |
+| [LSM303AGR accelerometer](https://pkg.go.dev/tinygo.org/x/drivers/lsm303agr) | [datasheet](https://www.st.com/resource/en/datasheet/lsm303agr.pdf) | I2C |
+| [LSM6DS3 accelerometer](https://pkg.go.dev/tinygo.org/x/drivers/lsm6ds3) | [datasheet](https://www.st.com/resource/en/datasheet/lsm6ds3.pdf) | I2C |
+| [LSM6DS3TR accelerometer](https://pkg.go.dev/tinygo.org/x/drivers/lsm6ds3tr) | [datasheet](https://www.st.com/resource/en/datasheet/lsm6ds3tr.pdf)| I2C |
+| [LSM6DSOX accelerometer](https://pkg.go.dev/tinygo.org/x/drivers/lsm6ds0x) | [datasheet](https://www.st.com/resource/en/datasheet/lsm6dsox.pdf) | I2C |
+| [LSM9DS1 accelerometer](https://pkg.go.dev/tinygo.org/x/drivers/lsm9ds1) | [datasheet](https://www.st.com/resource/en/datasheet/lsm9ds1.pdf)| I2C |
+| [MAG3110 magnetometer](https://pkg.go.dev/tinygo.org/x/drivers/mag3110) | [datasheet](https://www.nxp.com/docs/en/data-sheet/MAG3110.pdf) | I2C |
+| [Makey Button](https://pkg.go.dev/tinygo.org/x/drivers/makeybutton) | [datasheet](https://makeymakey.com/) | GPIO |
+| [MAX7219 & MAX7221 display driver](https://pkg.go.dev/tinygo.org/x/drivers/max72xx) | [datasheet](https://datasheets.maximintegrated.com/en/ds/MAX7219-MAX7221.pdf) | SPI |
+| [MCP23017 port expander](https://pkg.go.dev/tinygo.org/x/drivers/mcp23017) | [datasheet](https://ww1.microchip.com/downloads/en/DeviceDoc/20001952C.pdf) | I2C |
+| [MCP2515 Stand-Alone CAN Controller with SPI Interface](https://pkg.go.dev/tinygo.org/x/drivers/mcp2515) | [datasheet](https://ww1.microchip.com/downloads/en/DeviceDoc/MCP2515-Family-Data-Sheet-DS20001801K.pdf) | SPI |
+| [MCP3008 analog to digital converter (ADC)](https://pkg.go.dev/tinygo.org/x/drivers/mcp3008) | [datasheet](http://ww1.microchip.com/downloads/en/DeviceDoc/21295d.pdf) | SPI |
+| [Microphone - PDM](https://pkg.go.dev/tinygo.org/x/drivers/microphone) | [datasheet](https://cdn-learn.adafruit.com/assets/assets/000/049/977/original/MP34DT01-M.pdf) | I2S/PDM |
+| [MMA8653 accelerometer](https://pkg.go.dev/tinygo.org/x/drivers/mma8653) | [datasheet](https://www.nxp.com/docs/en/data-sheet/MMA8653FC.pdf) | I2C |
+| [MPU6050 accelerometer/gyroscope](https://pkg.go.dev/tinygo.org/x/drivers/mpu6050) | [datasheet](https://store.invensense.com/datasheets/invensense/MPU-6050_DataSheet_V3%204.pdf) | I2C |
+| [MPU6886 accelerometer/gyroscope](https://pkg.go.dev/tinygo.org/x/drivers/mpu6886) | [datasheet](https://github.com/m5stack/M5-Schematic/blob/master/datasheet/MPU-6886-000193%2Bv1.1_GHIC.PDF.pdf) | I2C |
+| [MPU9150 accelerometer/gyroscope](https://invensense.tdk.com/wp-content/uploads/2015/02/MPU-9150-Datasheet.pdf) | I2C |
+| [NDIR CO2 Sensor](https://pkg.go.dev/tinygo.org/x/drivers/ndir) | [datasheet](http://sandboxelectronics.com/?p=1126) | I2C |
+| [One Wire bus system](https://pkg.go.dev/tinygo.org/x/drivers/onewire) | [datasheet](https://en.wikipedia.org/wiki/1-Wire) | 1-wire |
+| [P1AM-100 Base Controller](https://pkg.go.dev/tinygo.org/x/drivers/p1am100) | [datasheet](https://facts-engineering.github.io/modules/P1AM-100/P1AM-100.html) | SPI |
+| [PCD8544 display](https://pkg.go.dev/tinygo.org/x/drivers/pcd8544) | [datasheet](http://eia.udg.edu/~forest/PCD8544_1.pdf) | SPI |
+| [PCF8523 real time clock](https://pkg.go.dev/tinygo.org/x/drivers/pcf8523) | [datasheet](https://www.nxp.com/docs/en/data-sheet/PCF8523.pdf) | I2C |
+| [PCF8563 real time clock](https://pkg.go.dev/tinygo.org/x/drivers/pcf8563) | [datasheet](https://www.nxp.com/docs/en/data-sheet/PCF8563.pdf) | I2C |
+| [QMI8658C accelerometer/gyroscope](https://pkg.go.dev/tinygo.org/x/drivers/qmi8658c) | [datasheet](https://www.qstcorp.com/upload/pdf/202202/%EF%BC%88%E5%B7%B2%E4%BC%A0%EF%BC%89QMI8658C%20datasheet%20rev%200.9.pdf) | I2C |
+| [Resistive Touchscreen (4-wire)](https://pkg.go.dev/tinygo.org/x/drivers/touch/resistive) | [datasheet](http://ww1.microchip.com/downloads/en/Appnotes/doc8091.pdf) | GPIO |
+| [Rotary Encoder](https://pkg.go.dev/tinygo.org/x/drivers/encoders) | [datasheet](https://www.mouser.com/datasheet/2/414/TTRB_S_A0002793947_1-2565369.pdf) | GPIO |
+| [RTL8720DN 2.4G/5G Dual Bands Wireless and BLE5.0](https://pkg.go.dev/tinygo.org/x/drivers/lsm6ds0xhttps://pkg.go.dev/tinygo.org/x/drivers/rtl8720dn) | [datasheet](https://www.seeedstudio.com/Realtek8720DN-2-4G-5G-Dual-Bands-Wireless-and-BLE5-0-Combo-Module-p-4442.html) | UART |
+| [SCD4x CO2 Sensor](https://pkg.go.dev/tinygo.org/x/drivers/scd4x) | [datasheet](https://sensirion.com/media/documents/C4B87CE6/627C2DCD/CD_DS_SCD40_SCD41_Datasheet_D1.pdf) | I2C |
+| [Semihosting](https://pkg.go.dev/tinygo.org/x/drivers/semihosting) | [datasheet](https://wiki.segger.com/Semihosting) | Debug |
+| [Semtech SX126x Lora](https://pkg.go.dev/tinygo.org/x/drivers/sx126x) | [datasheet](https://www.semtech.com/products/wireless-rf/lora-connect/sx1261) | SPI |
+| [Semtech SX127x Lora](https://pkg.go.dev/tinygo.org/x/drivers/sx127x) | [datasheet](https://www.semtech.com/products/wireless-rf/lora-connect/sx1276) | SPI |
+| [Servo](https://pkg.go.dev/tinygo.org/x/drivers/servo) | [datasheet](https://learn.sparkfun.com/tutorials/hobby-servo-tutorial/all) | PWM |
+| [SH1106 OLED display](https://pkg.go.dev/tinygo.org/x/drivers/sh1106) | [datasheet](https://www.velleman.eu/downloads/29/infosheets/sh1106_datasheet.pdf) | I2C / SPI |
+| [Shift register (PISO)](https://pkg.go.dev/tinygo.org/x/drivers/shiftregister) | [datasheet](https://en.wikipedia.org/wiki/Shift_register#Parallel-in_serial-out_\(PISO\)) | GPIO |
+| [Shift registers (SIPO)](https://pkg.go.dev/tinygo.org/x/drivers/shiftregister) | [datasheet](https://en.wikipedia.org/wiki/Shift_register#Serial-in_parallel-out_(SIPO)) | GPIO |
+| [SHT3x Digital Humidity Sensor](https://pkg.go.dev/tinygo.org/x/drivers/sht3x) | [datasheet](https://sensirion.com/media/documents/213E6A3B/63A5A569/Datasheet_SHT3x_DIS.pdf) | I2C |
+| [SHT4x Digital Humidity Sensor](https://pkg.go.dev/tinygo.org/x/drivers/sht4x) | [datasheet](https://sensirion.com/media/documents/33FD6951/63E1087C/Datasheet_SHT4x_1.pdf) | I2C |
+| [SHTC3 Digital Humidity Sensor (RH/T)](https://pkg.go.dev/tinygo.org/x/drivers/shtc3) | [datasheet](https://www.sensirion.com/fileadmin/user_upload/customers/sensirion/Dokumente/2_Humidity_Sensors/Datasheets/Sensirion_Humidity_Sensors_SHTC3_Datasheet.pdf)  | I2C |
+| [software I2C driver](https://pkg.go.dev/tinygo.org/x/drivers/i2csoft) | [datasheet](https://www.ti.com/lit/an/slva704/slva704.pdf) | GPIO |
+| [SPI NOR Flash Memory](https://pkg.go.dev/tinygo.org/x/drivers/flash) | [datasheet](https://en.wikipedia.org/wiki/Flash_memory#NOR_flash) | SPI/QSPI |
+| [SPI SDCARD/MMC](https://pkg.go.dev/tinygo.org/x/drivers/sdcard) | [datasheet](https://en.wikipedia.org/wiki/SD_card) | SPI |
+| [SSD1289 TFT color display](https://pkg.go.dev/tinygo.org/x/drivers/ssd1289) | [datasheet](http://aitendo3.sakura.ne.jp/aitendo_data/product_img/lcd/tft2/M032C1289TP/3.2-SSD1289.pdf) | GPIO |
+| [SSD1306 OLED display](https://pkg.go.dev/tinygo.org/x/drivers/ssd1306) | [datasheet](https://cdn-shop.adafruit.com/datasheets/SSD1306.pdf) | I2C / SPI |
+| [SSD1331 TFT color display](https://pkg.go.dev/tinygo.org/x/drivers/ssd1331) | [datasheet](https://www.crystalfontz.com/controllers/SolomonSystech/SSD1331/381/) | SPI |
+| [SSD1351 OLED display](https://pkg.go.dev/tinygo.org/x/drivers/ssd1351) | [datasheet](https://download.mikroe.com/documents/datasheets/ssd1351-revision-1.3.pdf) | SPI |
+| [ST7735 TFT color display](https://pkg.go.dev/tinygo.org/x/drivers/st7735) | [datasheet](https://www.crystalfontz.com/controllers/Sitronix/ST7735R/319/) | SPI |
+| [ST7789 TFT color display](https://pkg.go.dev/tinygo.org/x/drivers/st7789) | [datasheet](https://cdn-shop.adafruit.com/product-files/3787/3787_tft_QT154H2201__________20190228182902.pdf) | SPI |
+| [Stepper motor "Easystepper" controller](https://pkg.go.dev/tinygo.org/x/drivers/easystepper) | [datasheet](https://en.wikipedia.org/wiki/Stepper_motor) | GPIO |
+| [Thermistor](https://pkg.go.dev/tinygo.org/x/drivers/thermistor) | [datasheet](https://www.farnell.com/datasheets/33552.pdf) | ADC |
+| [TM1637 7-segment LED display](https://pkg.go.dev/tinygo.org/x/drivers/tm1637) | [datasheet](https://www.mcielectronics.cl/website_MCI/static/documents/Datasheet_TM1637.pdf) | I2C |
+| [TMP102 I2C Temperature Sensor](https://pkg.go.dev/tinygo.org/x/drivers/tmp102) | [datasheet](https://download.mikroe.com/documents/datasheets/tmp102-data-sheet.pdf) | I2C |
+| [TTP229 (BSF version) 16 keys or 8 keys touch pad detector](https://pkg.go.dev/tinygo.org/x/drivers/ttp229) | [datasheet](https://www.sunrom.com/download/SUNROM-TTP229-BSF_V1.1_EN.pdf) | GPIO |
+| [UC8151 All-in-one driver IC for ESL](https://pkg.go.dev/tinygo.org/x/drivers/uc8151) | [datasheet](https://www.buydisplay.com/download/ic/UC8151C.pdf) | I2C |
+| [VEML6070 UV light sensor](https://pkg.go.dev/tinygo.org/x/drivers/veml6070) | [datasheet](https://www.vishay.com/docs/84277/veml6070.pdf) | I2C |
+| [VL53L1X time-of-flight distance sensor](https://pkg.go.dev/tinygo.org/x/drivers/vl53l1x) | [datasheet](https://www.st.com/resource/en/datasheet/vl53l1x.pdf) | I2C |
+| [VL6180X time-of-flight distance sensor](https://pkg.go.dev/tinygo.org/x/drivers/vl6180x) | [datasheet](https://www.st.com/resource/en/datasheet/vl6180x.pdf) | I2C |
+| [Waveshare 2.13" (B & C) e-paper display](https://pkg.go.dev/tinygo.org/x/drivers/waveshare-epd/epd2in13x) | [datasheet](https://www.waveshare.com/w/upload/d/d3/2.13inch-e-paper-b-Specification.pdf) | SPI |
+| [Waveshare 2.13" e-paper display](https://pkg.go.dev/tinygo.org/x/drivers/waveshare-epd/epd2in13) | [datasheet](https://www.waveshare.com/w/upload/e/e6/2.13inch_e-Paper_Datasheet.pdf) | SPI |
+| [Waveshare 2.9" e-paper display (V1)](https://pkg.go.dev/tinygo.org/x/drivers/waveshare-epd/epd2in9) | [datasheet](https://www.waveshare.com/w/upload/e/e6/2.9inch_e-Paper_Datasheet.pdf) | SPI |
+| [Waveshare 4.2" e-paper B/W display](https://pkg.go.dev/tinygo.org/x/drivers/waveshare-epd/epd4in2) | [datasheet](https://www.waveshare.com/w/upload/6/6a/4.2inch-e-paper-specification.pdf) | SPI |
+| [Waveshare GC9A01 TFT round display](https://pkg.go.dev/tinygo.org/x/drivers/gc9a01) | [datasheet](https://www.waveshare.com/w/upload/5/5e/GC9A01A.pdf) | SPI |
+| [WS2812 RGB LED](https://pkg.go.dev/tinygo.org/x/drivers/ws2812) | [datasheet](https://cdn-shop.adafruit.com/datasheets/WS2812.pdf) | GPIO |
+| [XPT2046 touch controller](https://pkg.go.dev/tinygo.org/x/drivers/xpt2046) | [datasheet](http://grobotronics.com/images/datasheets/xpt2046-datasheet.pdf) | GPIO |
+
+We also give you the ability to add new drivers. If your device isn't listed here, please raise an issue in the [issue tracker](https://github.com/tinygo-org/drivers/issues).
+
+If you want to know more about how drivers are implemented please see the [Drivers page](../../concepts/drivers) under "Concepts".
diff --git a/content/docs/reference/go-compat-matrix.md b/content/docs/reference/go-compat-matrix.md
new file mode 100644
index 00000000..892f7a2f
--- /dev/null
+++ b/content/docs/reference/go-compat-matrix.md
@@ -0,0 +1,19 @@
+---
+title: " Go compatibility matrix"
+weight: 10
+description: >
+  Compatibility matrix between TinyGo versions and Go versions
+---
+
+|     TinyGo      |                Go 1.20                |                Go 1.19                |                Go 1.18                |                Go 1.17                |                Go 1.16                |                Go 1.15                |                Go 1.14                |                Go 1.13                |                Go 1.12                |                Go 1.11                |
+|:---------------:|:-------------------------------------:|:-------------------------------------:|:-------------------------------------:|:-------------------------------------:|:-------------------------------------:|:-------------------------------------:|:-------------------------------------:|:-------------------------------------:|:-------------------------------------:|:-------------------------------------:|
+| 0.27.0 - 0.30.0 |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |                                       |                                       |                                       |                                       |                                       |                                       |                                       |
+|     0.26.0      |                                       |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |                                       |                                       |                                       |                                       |                                       |                                       |                                       |
+| 0.24.0 - 0.25.0 |                                       |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |                                       |                                       |                                       |                                       |                                       |
+|     0.23.0      |                                       |                                       |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |                                       |                                       |                                       |                                       |
+| 0.20.0 - 0.22.0 |                                       |                                       |                                       |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |                                       |                                       |                                       |                                       |
+| 0.18.0 - 0.19.0 |                                       |                                       |                                       |                                       |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |                                       |                                       |
+|     0.17.0      |                                       |                                       |                                       |                                       |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |
+| 0.14.1 - 0.16.0 |                                       |                                       |                                       |                                       |                                       |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |
+| 0.13.0 - 0.14.0 |                                       |                                       |                                       |                                       |                                       |                                       |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |
+| 0.10.0 - 0.12.0 |                                       |                                       |                                       |                                       |                                       |                                       |                                       |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |  <span style="color: green">✔</span>  |
diff --git a/content/docs/reference/lang-support/_index.md b/content/docs/reference/lang-support/_index.md
new file mode 100644
index 00000000..ec4e3f7a
--- /dev/null
+++ b/content/docs/reference/lang-support/_index.md
@@ -0,0 +1,43 @@
+---
+title: "Go language features"
+weight: 6
+description: |
+  Which Go language features are supported by TinyGo and which are still a work in progress.
+---
+
+The TinyGo compiler implements all major Go language features, although some details are missing. Below you will find a description of some of the missing features, as of june 2023.
+
+If you're wondering "Does TinyGo support feature X", we often cannot give a good answer! The rest of this page gives a good indication, but other than that you will just have to try for yourself to see whether a particular piece of software works with TinyGo. There are just way too many edge cases that are not entirely supported or work slightly differently, many of which we don't even know about.
+
+## Cgo
+
+While TinyGo embeds the [Clang](https://clang.llvm.org/) compiler to parse `import "C"` blocks, some features of Cgo are still unsupported or may work slightly differently. For example, `#cgo` statements are only partially supported.
+
+## Reflection
+
+Many packages, especially in the standard library, rely on reflection to work. The `reflect` package has been re-implemented in TinyGo and most of it works, but some parts are not yet fully supported.
+
+## Maps
+
+Maps generally work fine, but may be slower than you expect them to be. There are a few reasons for this, one of which is that some types (like structs) may internally be compared using reflection instead of using a dedicated hash/compare function.
+
+## Standard library
+
+Due to the above missing pieces and because parts of the standard library depend on the particular compiler/runtime in use, many packages do not yet compile. See the [list of compiling packages here]({{<ref "stdlib.md">}}) (but note that "compiling" does not imply that works entirely).
+
+## Garbage collection
+
+Garbage collection generally works fine, but may work not as well on very small chips (AVR) and on WebAssembly. It is also a lot slower than the usual Go garbage collector.
+
+Careful design may avoid memory allocations in main loops where they can reduce performance a lot. You may want to compile with `-print-allocs=.` to find out where allocations happen and why they happen. For more information, see [heap allocation]({{<ref "heap-allocation.md">}}).
+
+## `recover` builtin
+
+The `recover` builtin is supported on most architectures, with the notable exception of WebAssembly. For WebAssembly, we need the [exception handling proposal](https://webassembly.org/roadmap/) which is implemented in browsers but is not implemented in many WASI runtimes.
+
+On architectures where `recover` is not implemented, a panic will always exit the program without running any deferred functions.
+
+Some notes on `recover` support in TinyGo:
+
+  * We don't follow the Go language specification to the letter, in particular `recover()` also returns a value in functions that aren't directly called by `defer` (meaning, it returns a value inside a function that is called by a deferred function). In practice, this happens very rarely. This inconsistency should eventually be fixed.
+  * Runtime panics can currently not be recovered from. This includes things like divide-by-zero and nil pointer dereferences, which are used in some standard library tests.
diff --git a/content/docs/reference/lang-support/stdlib.md b/content/docs/reference/lang-support/stdlib.md
new file mode 100644
index 00000000..7502a524
--- /dev/null
+++ b/content/docs/reference/lang-support/stdlib.md
@@ -0,0 +1,1804 @@
+
+---
+title: Packages supported by TinyGo
+---
+
+The following table shows all Go standard library packages and whether they can be imported by TinyGo. If they can't, you can click the 'no' link to jump to the explanation why the package cannot be compiled.
+
+Note that the fact they can be imported, does not mean that all functions and types in the program can be used. For example, sometimes using some functions or types of the package will still trigger compiler errors.
+
+Test results are for linux/amd64.
+
+Package | Importable | Passes tests
+--- | --- | --- |
+archive/tar |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#archivetar)  | 
+archive/zip |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+bufio |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#bufio)  | 
+bytes |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#bytes)  | 
+cmp |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+compress/bzip2 |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+compress/flate |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+compress/gzip |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#compressgzip)  | 
+compress/lzw |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+compress/zlib |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+container/heap |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+container/list |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+container/ring |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+context |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+crypto |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#crypto)  | 
+crypto/aes |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#cryptoaes)  | 
+crypto/cipher |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#cryptocipher)  | 
+crypto/des |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+crypto/dsa |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+crypto/ecdh |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#cryptoecdh)  | 
+crypto/ecdsa |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#cryptoecdsa)  | 
+crypto/ed25519 |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#cryptoed25519)  | 
+crypto/elliptic |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+crypto/fips140 |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+crypto/hkdf |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+crypto/hmac |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#cryptohmac)  | 
+crypto/md5 |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+crypto/mlkem |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#cryptomlkem)  | 
+crypto/pbkdf2 |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+crypto/rand |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+crypto/rc4 |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#cryptorc4)  | 
+crypto/rsa |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#cryptorsa)  | 
+crypto/sha1 |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+crypto/sha256 |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#cryptosha256)  | 
+crypto/sha3 |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+crypto/sha512 |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#cryptosha512)  | 
+crypto/subtle |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#cryptosubtle)  | 
+crypto/tls |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+crypto/x509 |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#cryptox509)  | 
+crypto/x509/pkix |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+database/sql |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#databasesql)  | 
+database/sql/driver |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+debug/buildinfo |  [<span style="color: red">✗</span> no](#debugbuildinfo)  |  <span style="color: gray">✗</span> no  | 
+debug/dwarf |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+debug/elf |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+debug/gosym |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#debuggosym)  | 
+debug/macho |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+debug/pe |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#debugpe)  | 
+debug/plan9obj |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+embed |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+encoding |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+encoding/ascii85 |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+encoding/asn1 |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+encoding/base32 |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+encoding/base64 |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+encoding/binary |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#encodingbinary)  | 
+encoding/csv |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+encoding/gob |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#encodinggob)  | 
+encoding/hex |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+encoding/json |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#encodingjson)  | 
+encoding/pem |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#encodingpem)  | 
+encoding/xml |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+errors |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#errors)  | 
+expvar |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+flag |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#flag)  | 
+fmt |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#fmt)  | 
+go/ast |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+go/build |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#gobuild)  | 
+go/build/constraint |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+go/constant |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#goconstant)  | 
+go/doc |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#godoc)  | 
+go/doc/comment |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#godoccomment)  | 
+go/format |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+go/importer |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#goimporter)  | 
+go/parser |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#goparser)  | 
+go/printer |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+go/scanner |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+go/token |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#gotoken)  | 
+go/types |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#gotypes)  | 
+go/version |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+hash |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+hash/adler32 |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+hash/crc32 |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#hashcrc32)  | 
+hash/crc64 |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+hash/fnv |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+hash/maphash |  [<span style="color: red">✗</span> no](#hashmaphash)  |  <span style="color: gray">✗</span> no  | 
+html |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+html/template |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#htmltemplate)  | 
+image |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+image/color |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#imagecolor)  | 
+image/color/palette |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+image/draw |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#imagedraw)  | 
+image/gif |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+image/jpeg |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#imagejpeg)  | 
+image/png |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+index/suffixarray |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+io |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#io)  | 
+io/fs |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+io/ioutil |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+iter |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#iter)  | 
+log |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#log)  | 
+log/slog |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#logslog)  | 
+log/syslog |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#logsyslog)  | 
+maps |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+math |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+math/big |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#mathbig)  | 
+math/bits |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#mathbits)  | 
+math/cmplx |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+math/rand |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#mathrand)  | 
+math/rand/v2 |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#mathrandv2)  | 
+mime |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+mime/multipart |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+mime/quotedprintable |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+net |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+net/http |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+net/http/cgi |  [<span style="color: red">✗</span> no](#nethttpcgi)  |  <span style="color: gray">✗</span> no  | 
+net/http/cookiejar |  [<span style="color: red">✗</span> no](#nethttpcookiejar)  |  <span style="color: gray">✗</span> no  | 
+net/http/fcgi |  [<span style="color: red">✗</span> no](#nethttpfcgi)  |  <span style="color: gray">✗</span> no  | 
+net/http/httptest |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+net/http/httptrace |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+net/http/httputil |  [<span style="color: red">✗</span> no](#nethttphttputil)  |  <span style="color: gray">✗</span> no  | 
+net/http/pprof |  [<span style="color: red">✗</span> no](#nethttppprof)  |  <span style="color: gray">✗</span> no  | 
+net/mail |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+net/netip |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#netnetip)  | 
+net/rpc |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#netrpc)  | 
+net/rpc/jsonrpc |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#netrpcjsonrpc)  | 
+net/smtp |  [<span style="color: red">✗</span> no](#netsmtp)  |  <span style="color: gray">✗</span> no  | 
+net/textproto |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+net/url |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#neturl)  | 
+os |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+os/exec |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#osexec)  | 
+os/signal |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#ossignal)  | 
+os/user |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+path |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+path/filepath |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#pathfilepath)  | 
+plugin |  [<span style="color: red">✗</span> no](#plugin)  |  <span style="color: gray">✗</span> no  | 
+reflect |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+regexp |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+regexp/syntax |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+slices |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#slices)  | 
+sort |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#sort)  | 
+strconv |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+strings |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#strings)  | 
+structs |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+sync |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+sync/atomic |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#syncatomic)  | 
+syscall |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#syscall)  | 
+testing |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+testing/fstest |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#testingfstest)  | 
+testing/iotest |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+testing/quick |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#testingquick)  | 
+testing/slogtest |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#testingslogtest)  | 
+testing/synctest |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#testingsynctest)  | 
+text/scanner |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+text/tabwriter |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+text/template |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#texttemplate)  | 
+text/template/parse |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+time |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#time)  | 
+time/tzdata |  [<span style="color: red">✗</span> no](#timetzdata)  |  <span style="color: gray">✗</span> no  | 
+unicode |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+unicode/utf16 |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+unicode/utf8 |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+unique |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+unsafe |  <span style="color: green">✔</span> yes  |  <span style="color: green">✔</span> yes  | 
+weak |  <span style="color: green">✔</span> yes  |  [<span style="color: red">✗</span> no](#weak)  | 
+
+
+
+## archive/tar
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    [tinygo: panic at <Go interface method>]
+    panic: runtime error at 0x000000000027ce50: nil pointer dereference
+    FAIL	archive/tar	1.265s
+
+
+
+
+
+
+
+
+## bufio
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    FAIL	bufio	0.000s
+    # bufio_test
+    /home/ron/.gvm/gos/go1.25/src/bufio/net_test.go:31:21: undefined: net.ListenUnix
+    /home/ron/.gvm/gos/go1.25/src/bufio/net_test.go:70:25: undefined: net.DialUnix
+
+
+
+
+
+
+## bytes
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    FAIL	bytes	0.000s
+    # bytes_test
+    /home/ron/.gvm/gos/go1.25/src/math/rand/rng.go:239:6: interp: running for more than 3m0s, timing out (executed calls: 459674)
+      %0 = icmp eq ptr %rng, null, !dbg !19916
+    
+    traceback:
+    /home/ron/.gvm/gos/go1.25/src/math/rand/rng.go:239:6:
+      %0 = icmp eq ptr %rng, null, !dbg !19916
+    /home/ron/.gvm/gos/go1.25/src/math/rand/rng.go:234:25:
+      %0 = call i64 @"(*math/rand.rngSource).Uint64"(ptr %rng, ptr undef), !dbg !19913
+    /home/ron/.gvm/gos/go1.25/src/math/rand/rand.go:96:50:
+      %4 = call i64 @"interface:{Int63:func:{}{basic:int64},Seed:func:{basic:int64}{}}.Int63$invoke"(ptr %invoke.func.value, ptr %invoke.func.typecode, ptr undef), !dbg !19907
+    /home/ron/.gvm/gos/go1.25/src/math/rand/rand.go:110:52:
+      %0 = call i64 @"(*math/rand.Rand).Int63"(ptr %r, ptr undef), !dbg !19906
+    /home/ron/.gvm/gos/go1.25/src/math/rand/rand.go:145:14:
+    [...more lines following...]
+
+
+
+
+
+
+
+
+
+
+
+
+## compress/gzip
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    --- FAIL: TestGZIPFilesHaveZeroMTimes (0.00s)
+        skipping test on non-builder
+        SkipNow is incomplete, requires runtime.Goexit()
+        error evaluating GOROOT:  lstat /usr/local/go: file does not exist
+        FailNow is incomplete, requires runtime.Goexit()
+        skipping: GOROOT directory not found: /usr/local/go
+        SkipNow is incomplete, requires runtime.Goexit()
+        error collecting list of .gz files in GOROOT:  lstat : file does not exist
+        FailNow is incomplete, requires runtime.Goexit()
+        expected to find some .gz files under GOROOT
+        FailNow is incomplete, requires runtime.Goexit()
+    FAIL
+    FAIL	compress/gzip	0.926s
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+## crypto
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    [tinygo: panic at <Go interface method>]
+    panic: runtime error at 0x0000000000265cab: nil pointer dereference
+    FAIL	crypto	1.139s
+
+
+
+
+
+
+## crypto/aes
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    panic: unimplemented: (reflect.Type).Method()
+    FAIL	crypto/aes	1.140s
+
+
+
+
+
+
+## crypto/cipher
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    FAIL	crypto/cipher	0.000s
+    /home/ron/.gvm/gos/go1.25/src/crypto/internal/sysrand/rand.go:48: linker could not find symbol crypto/internal/sysrand.fatal
+    /home/ron/Development/tinygo/tinygo-122/src/internal/syscall/unix/getrandom.go:26: linker could not find symbol runtime.vgetrandom
+
+
+
+
+
+
+
+
+
+
+## crypto/ecdh
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    --- FAIL: TestLinker (0.00s)
+        skipping test: 'go build' unavailable: /home/ron/.gvm/gos/go1.25/bin/go tool -n compile: files setting not implemented
+        SkipNow is incomplete, requires runtime.Goexit()
+        skipping test: 'go build' unavailable: /home/ron/.gvm/gos/go1.25/bin/go tool -n compile: files setting not implemented
+        SkipNow is incomplete, requires runtime.Goexit()
+        platform cannot run go tool
+        FailNow is incomplete, requires runtime.Goexit()
+        [ build -o hello.exe hello.go]: exec: no command
+        FailNow is incomplete, requires runtime.Goexit()
+        [./hello.exe]: directory setting not implemented
+        FailNow is incomplete, requires runtime.Goexit()
+        unexpected output: 
+        [ tool nm hello.exe]: exec: no command
+        FailNow is incomplete, requires runtime.Goexit()
+        no P256 symbols found in program using ecdh.P256, test is broken
+    [...more lines following...]
+
+
+
+
+
+
+## crypto/ecdsa
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    [tinygo: panic at /home/ron/.gvm/gos/go1.25/src/crypto/ecdsa/ecdsa_test.go:563:6]
+    panic: runtime error at 0x00000000002bd314: index out of range
+    FAIL	crypto/ecdsa	1.968s
+
+
+
+
+
+
+## crypto/ed25519
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    --- FAIL: TestEd25519Vectors (0.00s)
+        skipping test: 'go build' unavailable: /home/ron/.gvm/gos/go1.25/bin/go tool -n compile: files setting not implemented
+        SkipNow is incomplete, requires runtime.Goexit()
+        platform cannot run go tool
+        FailNow is incomplete, requires runtime.Goexit()
+         env GOMODCACHE: exec: no command
+        FailNow is incomplete, requires runtime.Goexit()
+        fetching filippo.io/mostly-harmless/ed25519vectors@v0.0.0-20210322192420-30a2d7243a94
+        failed to download filippo.io/mostly-harmless/ed25519vectors@v0.0.0-20210322192420-30a2d7243a94: exec: no command
+            
+        FailNow is incomplete, requires runtime.Goexit()
+        failed to parse 'go mod download': unexpected end of JSON input
+            
+        FailNow is incomplete, requires runtime.Goexit()
+        failed to read ed25519vectors.json: open ed25519vectors.json: file does not exist
+    [...more lines following...]
+
+
+
+
+
+
+
+
+
+
+
+
+## crypto/hmac
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    panic: unimplemented: (reflect.Type).Method()
+    FAIL	crypto/hmac	1.145s
+
+
+
+
+
+
+
+
+## crypto/mlkem
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    FAIL	crypto/mlkem	0.000s
+    /home/ron/.gvm/gos/go1.25/src/crypto/internal/sysrand/rand.go:48: linker could not find symbol crypto/internal/sysrand.fatal
+    /home/ron/Development/tinygo/tinygo-122/src/internal/syscall/unix/getrandom.go:26: linker could not find symbol runtime.vgetrandom
+
+
+
+
+
+
+
+
+
+
+## crypto/rc4
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    [tinygo: panic at /home/ron/.gvm/gos/go1.25/src/crypto/rc4/rc4.go]
+    panic: runtime error at 0x000000000025dd2d: index out of range
+    FAIL	crypto/rc4	1.171s
+
+
+
+
+
+
+## crypto/rsa
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    FAIL	crypto/rsa	0.000s
+    /home/ron/.gvm/gos/go1.25/src/crypto/internal/sysrand/rand.go:48: linker could not find symbol crypto/internal/sysrand.fatal
+    /home/ron/Development/tinygo/tinygo-122/src/internal/syscall/unix/getrandom.go:26: linker could not find symbol runtime.vgetrandom
+
+
+
+
+
+
+
+
+## crypto/sha256
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    panic: unimplemented: (reflect.Type).Method()
+    FAIL	crypto/sha256	1.171s
+
+
+
+
+
+
+
+
+## crypto/sha512
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    panic: unimplemented: (reflect.Type).Method()
+    FAIL	crypto/sha512	1.937s
+
+
+
+
+
+
+## crypto/subtle
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    panic: unimplemented: (reflect.Type).NumIn()
+    FAIL	crypto/subtle	1.112s
+
+
+
+
+
+
+
+
+## crypto/x509
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    FAIL	crypto/x509	0.000s
+    # crypto/x509_test
+    /home/ron/.gvm/gos/go1.25/src/crypto/x509/hybrid_pool_test.go:63:17: c.ConnectionState undefined (type *net.TLSConn has no field or method ConnectionState)
+
+
+
+
+
+
+
+
+## database/sql
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    FAIL	database/sql	0.000s
+    # database/sql
+    /home/ron/.gvm/gos/go1.25/src/database/sql/sql_test.go:1378:11: t.Context undefined (type *testing.T has no field or method Context, but does have unexported field context)
+    /home/ron/.gvm/gos/go1.25/src/database/sql/sql_test.go:1405:11: t.Context undefined (type *testing.T has no field or method Context, but does have unexported field context)
+    /home/ron/.gvm/gos/go1.25/src/database/sql/sql_test.go:1520:13: t.Context undefined (type *testing.T has no field or method Context, but does have unexported field context)
+    /home/ron/.gvm/gos/go1.25/src/database/sql/sql_test.go:1548:11: t.Context undefined (type *testing.T has no field or method Context, but does have unexported field context)
+    /home/ron/.gvm/gos/go1.25/src/database/sql/sql_test.go:2793:11: t.Context undefined (type *testing.T has no field or method Context, but does have unexported field context)
+    /home/ron/.gvm/gos/go1.25/src/database/sql/sql_test.go:2934:11: t.Context undefined (type *testing.T has no field or method Context, but does have unexported field context)
+    /home/ron/.gvm/gos/go1.25/src/database/sql/sql_test.go:3784:11: t.Context undefined (type *testing.T has no field or method Context, but does have unexported field context)
+    /home/ron/.gvm/gos/go1.25/src/database/sql/sql_test.go:4139:11: t.Context undefined (type *testing.T has no field or method Context, but does have unexported field context)
+    /home/ron/.gvm/gos/go1.25/src/database/sql/sql_test.go:4187:11: t.Context undefined (type *testing.T has no field or method Context, but does have unexported field context)
+    /home/ron/.gvm/gos/go1.25/src/database/sql/sql_test.go:4298:11: t.Context undefined (type *testing.T has no field or method Context, but does have unexported field context)
+    /home/ron/.gvm/gos/go1.25/src/database/sql/sql_test.go:4840:4: b.SetParallelism undefined (type *testing.B has no field or method SetParallelism)
+
+
+
+
+
+
+
+
+## debug/buildinfo
+
+
+
+The compiler gave the following error when this package was imported:
+
+
+    # debug/buildinfo
+    /home/ron/.gvm/gos/go1.25/src/debug/buildinfo/buildinfo.go:93:19: undefined: debug.ParseBuildInfo
+
+
+
+
+
+
+
+
+
+
+## debug/gosym
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    [tinygo: panic at /home/ron/.gvm/gos/go1.25/src/debug/elf/file.go:129:5]
+    panic: runtime error at 0x000000000026c8de: nil pointer dereference
+    FAIL	debug/gosym	1.203s
+
+
+
+
+
+
+
+
+## debug/pe
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    [tinygo: panic at /home/ron/.gvm/gos/go1.25/src/debug/pe/file_test.go]
+    panic: runtime error at 0x0000000000289e3d: index out of range
+    FAIL	debug/pe	1.191s
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+## encoding/binary
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    [tinygo: panic at /home/ron/.gvm/gos/go1.25/src/encoding/binary/binary.go:116:7]
+    panic: runtime error at 0x0000000000259ba1: index out of range
+    FAIL	encoding/binary	1.179s
+
+
+
+
+
+
+
+
+## encoding/gob
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    panic: reflect: unimplemented: AssignableTo with interface
+    FAIL	encoding/gob	1.124s
+
+
+
+
+
+
+
+
+## encoding/json
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    FAIL	encoding/json	0.000s
+    # encoding/json
+    /home/ron/.gvm/gos/go1.25/src/encoding/json/encode_test.go:1415:6: wg.Go undefined (type sync.WaitGroup has no field or method Go)
+
+
+
+
+
+
+## encoding/pem
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    panic: unimplemented: (reflect.Type).NumOut()
+    FAIL	encoding/pem	2.134s
+
+
+
+
+
+
+
+
+## errors
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    --- FAIL: TestAs (0.00s)
+        --- FAIL: TestAs/8:As(Errorf(...,_err),_0x74454aab5b60) (0.00s)
+            match: got true; want false
+            FailNow is incomplete, requires runtime.Goexit()
+            got &errors.errorString{s:"err"}, want <nil>
+            FailNow is incomplete, requires runtime.Goexit()
+        --- FAIL: TestAs/10:As(Errorf(...,_path_error),_0x74454aab5b60) (0.00s)
+            got errors_test.wrapped{msg:"path error", err:(*fs.PathError)(0x74454aabdd80)}, want &fs.PathError{Op:"open", Path:"non-existing", Err:(*errors.errorString)(0x264ed8)}
+            FailNow is incomplete, requires runtime.Goexit()
+        --- FAIL: TestAs/16:As(Errorf(...,_multiError),_0x74454aab5b60) (0.00s)
+            got errors_test.multiErr{errors_test.wrapped{msg:"path error", err:(*fs.PathError)(0x74454aabdd80)}}, want &fs.PathError{Op:"open", Path:"non-existing", Err:(*errors.errorString)(0x264ed8)}
+            FailNow is incomplete, requires runtime.Goexit()
+    FAIL
+    FAIL	errors	0.002s
+
+
+
+
+
+
+
+
+## flag
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    --- FAIL: TestExitCode (0.00s)
+        unexpected exit code for test case {flag:-h flagHandle: expectExit:0} 
+            : got -1, expect 0
+        unexpected exit code for test case {flag:-help flagHandle: expectExit:0} 
+            : got -1, expect 0
+        unexpected exit code for test case {flag:-undefined flagHandle: expectExit:2} 
+            : got -1, expect 2
+        unexpected exit code for test case {flag:-h flagHandle:h expectExit:123} 
+            : got -1, expect 123
+        unexpected exit code for test case {flag:-help flagHandle:help expectExit:123} 
+            : got -1, expect 123
+    --- FAIL: TestDefineAfterSet (0.00s)
+        DefineAfterSet
+            : expected panic("flag myFlag set at .*/flag_test.go:.* before being defined"), but got panic("flag myFlag set at ?:0 before being defined")
+    FAIL
+    [...more lines following...]
+
+
+
+
+
+
+## fmt
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    panic: unimplemented: (reflect.Value).Method()
+    FAIL	fmt	1.137s
+
+
+
+
+
+
+
+
+## go/build
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    --- FAIL: TestDotSlashImport (0.01s)
+        import ".": unknown compiler "tinygo"
+        FailNow is incomplete, requires runtime.Goexit()
+        import "./file": unknown compiler "tinygo"
+        FailNow is incomplete, requires runtime.Goexit()
+    --- FAIL: TestLocalDirectory (0.00s)
+        import ".": unknown compiler "tinygo"
+        FailNow is incomplete, requires runtime.Goexit()
+        ImportPath=".", want "go/build"
+        FailNow is incomplete, requires runtime.Goexit()
+    --- FAIL: TestImportCmd (0.00s)
+        go/build: go list cmd/internal/objfile: files setting not implemented
+            
+            
+        FailNow is incomplete, requires runtime.Goexit()
+    [...more lines following...]
+
+
+
+
+
+
+
+
+## go/constant
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    [tinygo: panic at /home/ron/.gvm/gos/go1.25/src/go/constant/value.go]
+    panic: runtime error at 0x0000000000268d95: divide by zero
+    FAIL	go/constant	1.096s
+
+
+
+
+
+
+## go/doc
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    panic: unimplemented: (reflect.Type).NumOut()
+    FAIL	go/doc	1.126s
+
+
+
+
+
+
+## go/doc/comment
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    --- FAIL: TestStd (0.00s)
+        skipping test: 'go build' unavailable: /home/ron/.gvm/gos/go1.25/bin/go tool -n compile: files setting not implemented
+        SkipNow is incomplete, requires runtime.Goexit()
+        platform cannot run go tool
+        FailNow is incomplete, requires runtime.Goexit()
+        exec: no command
+        FailNow is incomplete, requires runtime.Goexit()
+        stdPkgs is out of date: regenerate with 'go generate'
+            diff stdPkgs want
+            --- stdPkgs
+            +++ want
+            @@ -1,40 +1,1 @@
+            -bufio
+            -bytes
+            -cmp
+    [...more lines following...]
+
+
+
+
+
+
+
+
+## go/importer
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    [tinygo: panic at <Go interface method>]
+    panic: runtime error at 0x000000000033f5b1: nil pointer dereference
+    FAIL	go/importer	1.091s
+
+
+
+
+
+
+## go/parser
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    FAIL	go/parser	1.237s
+
+
+
+
+
+
+
+
+
+
+## go/token
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    panic: reflect: unimplemented: AssignableTo with interface
+    FAIL	go/token	1.130s
+
+
+
+
+
+
+## go/types
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    FAIL	go/types	0.000s
+    # go/types_test
+    /home/ron/.gvm/gos/go1.25/src/go/types/self_test.go:102:4: b.ReportMetric undefined (type *testing.B has no field or method ReportMetric)
+
+
+
+
+
+
+
+
+
+
+
+
+## hash/crc32
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    panic: not available
+    FAIL	hash/crc32	1.194s
+
+
+
+
+
+
+
+
+
+
+## hash/maphash
+
+
+
+The compiler gave the following error when this package was imported:
+
+
+    # hash/maphash
+    /home/ron/.gvm/gos/go1.25/src/hash/maphash/maphash.go:295:6: undefined: abi.EscapeNonString
+    /home/ron/.gvm/gos/go1.25/src/hash/maphash/maphash.go:301:6: undefined: abi.EscapeNonString
+
+
+
+
+
+
+
+
+## html/template
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    panic: unimplemented: (reflect.Type).NumOut()
+    FAIL	html/template	1.124s
+
+
+
+
+
+
+
+
+## image/color
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    panic: unimplemented: (reflect.Type).NumIn()
+    FAIL	image/color	1.614s
+
+
+
+
+
+
+
+
+## image/draw
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    panic: unimplemented: (reflect.Type).NumIn()
+    FAIL	image/draw	1.592s
+
+
+
+
+
+
+
+
+## image/jpeg
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    FAIL	image/jpeg	0.000s
+    /home/ron/.gvm/gos/go1.25/src/image/jpeg/reader_test.go:253: linker could not find symbol runtime/debug.SetTraceback
+
+
+
+
+
+
+
+
+
+
+## io
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    --- FAIL: TestMultiWriter_WriteStringSingleAlloc (0.00s)
+        num allocations = 0; want 1
+    --- FAIL: TestMultiWriterSingleChainFlatten (0.00s)
+        multiWriter did not flatten chained multiWriters: expected writeDepth 12, got 4
+    --- FAIL: TestMultiReaderFlatten (0.00s)
+        multiReader did not flatten chained multiReaders: expected readDepth 3, got 1
+    --- FAIL: TestMultiReaderFreesExhaustedReaders (5.00s)
+        timeout waiting for collection of buf1
+        FailNow is incomplete, requires runtime.Goexit()
+    FAIL
+    FAIL	io	5.030s
+
+
+
+
+
+
+
+
+
+
+## iter
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    --- FAIL: TestPull (0.00s)
+        --- FAIL: TestPull/0 (0.00s)
+            have 0 extra goroutines, want 1
+            have 0 extra goroutines, want 1
+        --- FAIL: TestPull/1 (0.00s)
+            have 0 extra goroutines, want 1
+            have 0 extra goroutines, want 1
+            have 0 extra goroutines, want 1
+        --- FAIL: TestPull/2 (0.00s)
+            have 0 extra goroutines, want 1
+            have 0 extra goroutines, want 1
+            have 0 extra goroutines, want 1
+            have 0 extra goroutines, want 1
+        --- FAIL: TestPull/3 (0.00s)
+            have 0 extra goroutines, want 1
+    [...more lines following...]
+
+
+
+
+
+
+## log
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    --- FAIL: TestAll (0.00s)
+        log output should match "^.*/[A-Za-z0-9_\\-]+\\.go:(67|69): hello 23 world$" is "???:0: hello 23 world"
+        log output should match "^.*/[A-Za-z0-9_\\-]+\\.go:(67|69): hello 23 world$" is "???:0: hello 23 world"
+        log output should match "^[A-Za-z0-9_\\-]+\\.go:(67|69): hello 23 world$" is "???:0: hello 23 world"
+        log output should match "^[A-Za-z0-9_\\-]+\\.go:(67|69): hello 23 world$" is "???:0: hello 23 world"
+        log output should match "^[A-Za-z0-9_\\-]+\\.go:(67|69): hello 23 world$" is "???:0: hello 23 world"
+        log output should match "^[A-Za-z0-9_\\-]+\\.go:(67|69): hello 23 world$" is "???:0: hello 23 world"
+        log output should match "^XXX[0-9][0-9][0-9][0-9]/[0-9][0-9]/[0-9][0-9] [0-9][0-9]:[0-9][0-9]:[0-9][0-9]\\.[0-9][0-9][0-9][0-9][0-9][0-9] .*/[A-Za-z0-9_\\-]+\\.go:(67|69): hello 23 world$" is "XXX2025/08/19 17:27:53.073915 ???:0: hello 23 world"
+        log output should match "^XXX[0-9][0-9][0-9][0-9]/[0-9][0-9]/[0-9][0-9] [0-9][0-9]:[0-9][0-9]:[0-9][0-9]\\.[0-9][0-9][0-9][0-9][0-9][0-9] .*/[A-Za-z0-9_\\-]+\\.go:(67|69): hello 23 world$" is "XXX2025/08/19 17:27:53.073938 ???:0: hello 23 world"
+        log output should match "^XXX[0-9][0-9][0-9][0-9]/[0-9][0-9]/[0-9][0-9] [0-9][0-9]:[0-9][0-9]:[0-9][0-9]\\.[0-9][0-9][0-9][0-9][0-9][0-9] [A-Za-z0-9_\\-]+\\.go:(67|69): hello 23 world$" is "XXX2025/08/19 17:27:53.074037 ???:0: hello 23 world"
+        log output should match "^XXX[0-9][0-9][0-9][0-9]/[0-9][0-9]/[0-9][0-9] [0-9][0-9]:[0-9][0-9]:[0-9][0-9]\\.[0-9][0-9][0-9][0-9][0-9][0-9] [A-Za-z0-9_\\-]+\\.go:(67|69): hello 23 world$" is "XXX2025/08/19 17:27:53.074058 ???:0: hello 23 world"
+        log output should match "^[0-9][0-9][0-9][0-9]/[0-9][0-9]/[0-9][0-9] [0-9][0-9]:[0-9][0-9]:[0-9][0-9]\\.[0-9][0-9][0-9][0-9][0-9][0-9] .*/[A-Za-z0-9_\\-]+\\.go:(67|69): XXXhello 23 world$" is "2025/08/19 17:27:53.074159 ???:0: XXXhello 23 world"
+        log output should match "^[0-9][0-9][0-9][0-9]/[0-9][0-9]/[0-9][0-9] [0-9][0-9]:[0-9][0-9]:[0-9][0-9]\\.[0-9][0-9][0-9][0-9][0-9][0-9] .*/[A-Za-z0-9_\\-]+\\.go:(67|69): XXXhello 23 world$" is "2025/08/19 17:27:53.074179 ???:0: XXXhello 23 world"
+        log output should match "^[0-9][0-9][0-9][0-9]/[0-9][0-9]/[0-9][0-9] [0-9][0-9]:[0-9][0-9]:[0-9][0-9]\\.[0-9][0-9][0-9][0-9][0-9][0-9] [A-Za-z0-9_\\-]+\\.go:(67|69): XXXhello 23 world$" is "2025/08/19 17:27:53.074275 ???:0: XXXhello 23 world"
+        log output should match "^[0-9][0-9][0-9][0-9]/[0-9][0-9]/[0-9][0-9] [0-9][0-9]:[0-9][0-9]:[0-9][0-9]\\.[0-9][0-9][0-9][0-9][0-9][0-9] [A-Za-z0-9_\\-]+\\.go:(67|69): XXXhello 23 world$" is "2025/08/19 17:27:53.074379 ???:0: XXXhello 23 world"
+    [...more lines following...]
+
+
+
+
+
+
+## log/slog
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    FAIL	log/slog	0.000s
+    # log/slog
+    /home/ron/.gvm/gos/go1.25/src/log/slog/handler_test.go:661:27: t.Context undefined (type *testing.T has no field or method Context, but does have unexported field context)
+
+
+
+
+
+
+## log/syslog
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    FAIL	log/syslog	0.000s
+    # log/syslog
+    /home/ron/.gvm/gos/go1.25/src/log/syslog/syslog_test.go:35:21: oe.Temporary undefined (type *net.OpError has no field or method Temporary)
+    /home/ron/.gvm/gos/go1.25/src/log/syslog/syslog_test.go:110:15: undefined: net.ListenPacket
+
+
+
+
+
+
+
+
+
+
+## math/big
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    FAIL	math/big	0.000s
+    # math/big
+    /home/ron/.gvm/gos/go1.25/src/math/bits/bits.go:387:10: interp: running for more than 3m0s, timing out (executed calls: 28402189)
+      %0 = add i64 %x, %y, !dbg !31773
+    
+    traceback:
+    /home/ron/.gvm/gos/go1.25/src/math/bits/bits.go:387:10:
+      %0 = add i64 %x, %y, !dbg !31773
+    /home/ron/.gvm/gos/go1.25/src/math/bits/bits.go:365:19:
+      %10 = call { i64, i64 } @"math/bits.Add64"(i64 %x, i64 %y, i64 %carry, ptr undef), !dbg !31791
+    /home/ron/.gvm/gos/go1.25/src/math/big/arith.go:52:19:
+      %3 = call { i64, i64 } @"math/bits.Add"(i64 %2, i64 %c, i64 0, ptr undef), !dbg !31780
+    /home/ron/.gvm/gos/go1.25/src/math/big/arith.go:250:24:
+      %14 = call { i64, i64 } @"math/big.mulAddWWW_g"(i64 %13, i64 %y, i64 %7, ptr undef), !dbg !31791
+    /home/ron/.gvm/gos/go1.25/src/math/big/arith_decl_pure.go:26:20:
+    [...more lines following...]
+
+
+
+
+
+
+## math/bits
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    [tinygo: panic at /home/ron/.gvm/gos/go1.25/src/math/bits/bits.go:510:21]
+    panic: runtime error at 0x000000000022bbc6: divide by zero
+    FAIL	math/bits	1.133s
+
+
+
+
+
+
+
+
+## math/rand
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    panic: unimplemented: (reflect.Type).Method()
+    FAIL	math/rand	3.214s
+
+
+
+
+
+
+## math/rand/v2
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    panic: unimplemented: (reflect.Type).Method()
+    FAIL	math/rand/v2	5.460s
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+## net/http/cgi
+
+
+
+The compiler gave the following error when this package was imported:
+
+
+    ../../../../../tmp/tinygo-test-2530946319/main.go:2:8: package net/http/cgi is not in std (/home/ron/.cache/tinygo/goroot-238b5dc21737dc58a4711a1403436936af03af6c444855d3b1e3097f3f44652b/src/net/http/cgi)
+
+
+
+
+
+
+## net/http/cookiejar
+
+
+
+The compiler gave the following error when this package was imported:
+
+
+    ../../../../../tmp/tinygo-test-3869624494/main.go:2:8: package net/http/cookiejar is not in std (/home/ron/.cache/tinygo/goroot-238b5dc21737dc58a4711a1403436936af03af6c444855d3b1e3097f3f44652b/src/net/http/cookiejar)
+
+
+
+
+
+
+## net/http/fcgi
+
+
+This package cannot be imported because the following dependencies cannot be compiled:
+
+  * [net/http/cgi](#nethttpcgi)
+
+
+
+
+
+
+
+
+
+## net/http/httputil
+
+
+
+The compiler gave the following error when this package was imported:
+
+
+    ../../../../../tmp/tinygo-test-4082382619/main.go:2:8: package net/http/httputil is not in std (/home/ron/.cache/tinygo/goroot-238b5dc21737dc58a4711a1403436936af03af6c444855d3b1e3097f3f44652b/src/net/http/httputil)
+
+
+
+
+
+
+## net/http/pprof
+
+
+
+The compiler gave the following error when this package was imported:
+
+
+    ../../../../../tmp/tinygo-test-2746811948/main.go:2:8: package net/http/pprof is not in std (/home/ron/.cache/tinygo/goroot-238b5dc21737dc58a4711a1403436936af03af6c444855d3b1e3097f3f44652b/src/net/http/pprof)
+
+
+
+
+
+
+
+
+## net/netip
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    --- FAIL: TestInlining (0.00s)
+        skipping test: 'go build' unavailable: /home/ron/.gvm/gos/go1.25/bin/go tool -n compile: files setting not implemented
+        SkipNow is incomplete, requires runtime.Goexit()
+        skipping test: 'go build' unavailable: /home/ron/.gvm/gos/go1.25/bin/go tool -n compile: files setting not implemented
+        SkipNow is incomplete, requires runtime.Goexit()
+        platform cannot run go tool
+        FailNow is incomplete, requires runtime.Goexit()
+        go build: exec: no command, 
+        FailNow is incomplete, requires runtime.Goexit()
+        "(*uint128).halves" is no longer inlinable
+        "Addr.BitLen" is no longer inlinable
+        "Addr.hasZone" is no longer inlinable
+        "Addr.Is4" is no longer inlinable
+        "Addr.Is4In6" is no longer inlinable
+        "Addr.Is6" is no longer inlinable
+    [...more lines following...]
+
+
+
+
+
+
+## net/rpc
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    panic: reflect: unimplemented: AssignableTo with interface
+    FAIL	net/rpc	1.093s
+
+
+
+
+
+
+## net/rpc/jsonrpc
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    panic: reflect: unimplemented: AssignableTo with interface
+    FAIL	net/rpc/jsonrpc	1.100s
+
+
+
+
+
+
+## net/smtp
+
+
+
+The compiler gave the following error when this package was imported:
+
+
+    # net/smtp
+    /home/ron/.gvm/gos/go1.25/src/net/smtp/smtp.go:72:24: undefined: tls.Conn
+    /home/ron/.gvm/gos/go1.25/src/net/smtp/smtp.go:172:25: undefined: tls.Conn
+
+
+
+
+
+
+
+
+## net/url
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    panic: reflect: unimplemented: AssignableTo with interface
+    FAIL	net/url	1.168s
+
+
+
+
+
+
+
+
+## os/exec
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    FAIL	os/exec	0.000s
+    # os/exec_test
+    /home/ron/.gvm/gos/go1.25/src/os/exec/exec_test.go:260:17: undefined: net.FileListener
+    /home/ron/.gvm/gos/go1.25/src/os/exec/exec_test.go:405:92: cmd.ProcessState.Pid undefined (type *os.ProcessState has no field or method Pid)
+    /home/ron/.gvm/gos/go1.25/src/os/exec/exec_test.go:704:34: ln.(*net.TCPListener).File undefined (type *net.TCPListener has no field or method File)
+    /home/ron/.gvm/gos/go1.25/src/os/exec/exec_test.go:709:18: undefined: net.FileListener
+    /home/ron/.gvm/gos/go1.25/src/os/exec/exec_test.go:720:5: ts.StartTLS undefined (type *httptest.Server has no field or method StartTLS)
+    /home/ron/.gvm/gos/go1.25/src/os/exec/exec_test.go:809:35: ln.(*net.TCPListener).File undefined (type *net.TCPListener has no field or method File)
+
+
+
+
+
+
+## os/signal
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    FAIL	os/signal	0.000s
+    /home/ron/.gvm/gos/go1.25/src/os/signal/signal_unix.go:61: linker could not find symbol os/signal.signal_ignored
+    /home/ron/Development/tinygo/tinygo-122/src/syscall/syscall_linux.go:1127: linker could not find symbol syscall.runtime_doAllThreadsSyscall
+
+
+
+
+
+
+
+
+
+
+## path/filepath
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    --- FAIL: TestWindowsGlob (0.01s)
+        skipping windows specific test
+        SkipNow is incomplete, requires runtime.Goexit()
+        tmpDir path "/tmp/TestWindowsGlob235874332/000" must have drive letter in it
+        FailNow is incomplete, requires runtime.Goexit()
+        Glob("/tmp/TestWindowsGlob235874332/000\\a") returns [], but ["/tmp/TestWindowsGlob235874332/000\\a"] expected
+        Glob("/tmp/TestWindowsGlob235874332/000\\a") returns [], but ["/tmp/TestWindowsGlob235874332/000\\a"] expected
+        Glob("/tmp/TestWindowsGlob235874332/000\\a") returns [], but ["/tmp/TestWindowsGlob235874332/000\\a"] expected
+        Glob("/tmp/TestWindowsGlob235874332/000\\b") returns [], but ["/tmp/TestWindowsGlob235874332/000\\b"] expected
+        Glob("/tmp/TestWindowsGlob235874332/000\\b") returns [], but ["/tmp/TestWindowsGlob235874332/000\\b"] expected
+        Glob("/tmp/TestWindowsGlob235874332/000\\b") returns [], but ["/tmp/TestWindowsGlob235874332/000\\b"] expected
+        Glob("/tmp/TestWindowsGlob235874332/000\\*") returns [], but ["/tmp/TestWindowsGlob235874332/000\\a" "/tmp/TestWindowsGlob235874332/000\\b" "/tmp/TestWindowsGlob235874332/000\\dir"] expected
+        Glob("/tmp/TestWindowsGlob235874332/000\\*") returns [], but ["/tmp/TestWindowsGlob235874332/000\\a" "/tmp/TestWindowsGlob235874332/000\\b" "/tmp/TestWindowsGlob235874332/000\\dir"] expected
+        Glob("/tmp/TestWindowsGlob235874332/000\\*") returns [], but ["/tmp/TestWindowsGlob235874332/000\\a" "/tmp/TestWindowsGlob235874332/000\\b" "/tmp/TestWindowsGlob235874332/000\\dir"] expected
+        Glob("/tmp/TestWindowsGlob235874332/000\\d*") returns [], but ["/tmp/TestWindowsGlob235874332/000\\dir"] expected
+    [...more lines following...]
+
+
+
+
+
+
+## plugin
+
+
+
+The compiler gave the following error when this package was imported:
+
+
+    # plugin
+    /home/ron/.gvm/gos/go1.25/src/plugin/plugin_dlopen.go:10:6: not implemented: build constraints in #cgo line
+
+
+
+
+
+
+
+
+
+
+
+
+## slices
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    [tinygo: panic at /home/ron/.gvm/gos/go1.25/src/slices/slices.go]
+    panic: runtime error at 0x000000000028c61f: slice out of range
+    FAIL	slices	1.098s
+
+
+
+
+
+
+## sort
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    --- FAIL: TestCountStableOps (1.11s)
+        Counting skipped as non-verbose mode.
+        SkipNow is incomplete, requires runtime.Goexit()
+        Stable      100 elements:         963 Swap,        835 Less
+        Stable      300 elements:        3953 Swap,       3030 Less
+        Stable     1000 elements:       19708 Swap,      12302 Less
+        Stable     3000 elements:       81453 Swap,      42760 Less
+        Stable    10000 elements:      347361 Swap,     165461 Less
+        Stable    30000 elements:     1341839 Swap,     558511 Less
+        Stable   100000 elements:     5790294 Swap,    2084460 Less
+        Stable   300000 elements:    20448959 Swap,    6866868 Less
+        Stable  1000000 elements:    84452769 Swap,   25115173 Less
+    --- FAIL: TestCountSortOps (0.94s)
+        Counting skipped as non-verbose mode.
+        SkipNow is incomplete, requires runtime.Goexit()
+    [...more lines following...]
+
+
+
+
+
+
+
+
+## strings
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    FAIL	strings	0.000s
+    # strings_test
+    /home/ron/Development/tinygo/tinygo-122/src/runtime/runtime.go:48:6: interp: running for more than 3m0s, timing out (executed calls: 661832)
+      call void @llvm.memmove.p0.p0.i64(ptr %dst, ptr %src, i64 %size, i1 false), !dbg !20231
+    
+    traceback:
+    /home/ron/Development/tinygo/tinygo-122/src/runtime/runtime.go:48:6:
+      call void @llvm.memmove.p0.p0.i64(ptr %dst, ptr %src, i64 %size, i1 false), !dbg !20231
+    /home/ron/Development/tinygo/tinygo-122/src/runtime/slice.go:21:10:
+      call void @runtime.memmove(ptr %7, ptr %elemsBuf, i64 %8, ptr undef), !dbg !20261
+    /home/ron/.gvm/gos/go1.25/src/strings/strings_test.go:1884:13:
+      %append.new = call { ptr, i64, i64 } @runtime.sliceAppend(ptr %append.srcBuf, ptr %append.elemsBuf, i64 %append.srcLen, i64 %append.srcCap, i64 %append.elemsLen, i64 1, ptr undef), !dbg !20263
+    /home/ron/.gvm/gos/go1.25/src/strings:
+      %56 = call %runtime._string @strings_test.makeBenchInputHard(ptr undef), !dbg !20242
+    
+    [...more lines following...]
+
+
+
+
+
+
+
+
+
+
+## sync/atomic
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    [tinygo: panic at /home/ron/.gvm/gos/go1.25/src/sync/atomic/doc.go:93:6]
+    panic: runtime error at 0x000000000025ef75: caught signal SIGSEGV
+    FAIL	sync/atomic	3.845s
+
+
+
+
+
+
+## syscall
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    FAIL	syscall	0.000s
+    # syscall_test
+    /home/ron/.gvm/gos/go1.25/src/syscall/creds_test.go:53:19: undefined: net.FileConn
+    /home/ron/.gvm/gos/go1.25/src/syscall/creds_test.go:60:19: undefined: net.FileConn
+    /home/ron/.gvm/gos/go1.25/src/syscall/syscall_linux_test.go:758:37: t.Context undefined (type *testing.T has no field or method Context, but does have unexported field context)
+    /home/ron/.gvm/gos/go1.25/src/syscall/syscall_linux_test.go:851:37: t.Context undefined (type *testing.T has no field or method Context, but does have unexported field context)
+    /home/ron/.gvm/gos/go1.25/src/syscall/syscall_unix_test.go:183:16: undefined: net.FileConn
+    /home/ron/.gvm/gos/go1.25/src/syscall/syscall_unix_test.go:238:14: undefined: net.UnixConn
+    /home/ron/.gvm/gos/go1.25/src/syscall/syscall_unix_test.go:242:18: undefined: net.FileConn
+
+
+
+
+
+
+
+
+## testing/fstest
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    [tinygo: panic at <Go interface method>]
+    panic: runtime error at 0x0000000000230594: nil pointer dereference
+    FAIL	testing/fstest	1.149s
+
+
+
+
+
+
+
+
+## testing/quick
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    panic: unimplemented: (reflect.Type).NumIn()
+    FAIL	testing/quick	2.031s
+
+
+
+
+
+
+## testing/slogtest
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    panic: runtime.Caller failed
+    FAIL	testing/slogtest	1.130s
+
+
+
+
+
+
+## testing/synctest
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    FAIL	testing/synctest	0.000s
+    # testing/synctest_test
+    /home/ron/.gvm/gos/go1.25/src/testing/synctest/example_test.go:49:39: t.Context undefined (type *testing.T has no field or method Context, but does have unexported field context)
+    /home/ron/.gvm/gos/go1.25/src/testing/synctest/example_test.go:78:40: t.Context undefined (type *testing.T has no field or method Context, but does have unexported field context)
+    /home/ron/.gvm/gos/go1.25/src/testing/synctest/example_test.go:109:4: unknown field DialContext in struct literal of type http.Transport
+    /home/ron/.gvm/gos/go1.25/src/testing/synctest/example_test.go:113:4: unknown field ExpectContinueTimeout in struct literal of type http.Transport
+    /home/ron/.gvm/gos/go1.25/src/testing/synctest/synctest_test.go:106:8: t.Context undefined (type *testing.T has no field or method Context, but does have unexported field context)
+
+
+
+
+
+
+
+
+
+
+## text/template
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    panic: unimplemented: (reflect.Type).NumOut()
+    FAIL	text/template	1.128s
+
+
+
+
+
+
+
+
+## time
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    FAIL	time	0.000s
+    # time_test
+    /home/ron/.gvm/gos/go1.25/src/time/sleep_test.go:977:4: b.ReportMetric undefined (type *testing.B has no field or method ReportMetric)
+    /home/ron/.gvm/gos/go1.25/src/time/sleep_test.go:978:4: b.ReportMetric undefined (type *testing.B has no field or method ReportMetric)
+    /home/ron/.gvm/gos/go1.25/src/time/sleep_test.go:979:4: b.ReportMetric undefined (type *testing.B has no field or method ReportMetric)
+    /home/ron/.gvm/gos/go1.25/src/time/sleep_test.go:1050:8: b.ReportMetric undefined (type *testing.B has no field or method ReportMetric)
+    /home/ron/.gvm/gos/go1.25/src/time/sleep_test.go:1051:8: b.ReportMetric undefined (type *testing.B has no field or method ReportMetric)
+    /home/ron/.gvm/gos/go1.25/src/time/sleep_test.go:1052:8: b.ReportMetric undefined (type *testing.B has no field or method ReportMetric)
+
+
+
+
+
+
+## time/tzdata
+
+
+
+The compiler gave the following error when this package was imported:
+
+
+    /home/ron/Development/tinygo/tinygo-122/src/runtime/scheduler_threads.go:26: linker could not find symbol time.registerLoadFromEmbeddedTZData
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+## weak
+
+
+
+The compiler gave the following error when running the tests for this package:
+
+
+    FAIL	weak	0.000s
+    /home/ron/.gvm/gos/go1.25/src/weak/pointer.go: linker could not find symbol weak.runtime_makeStrongFromWeak
+    /home/ron/.gvm/gos/go1.25/src/weak/pointer.go: linker could not find symbol weak.runtime_makeStrongFromWeak
+
+
+
+
+
diff --git a/content/docs/reference/machine.md b/content/docs/reference/machine.md
new file mode 100644
index 00000000..d126b150
--- /dev/null
+++ b/content/docs/reference/machine.md
@@ -0,0 +1,390 @@
+---
+title: "machine package"
+weight: 5
+description: >
+  How to interact with peripherals exposed through the `machine` package.
+---
+
+## GPIO
+
+
+```go
+type Pin uint8
+
+const NoPin = Pin(0xff)
+```
+
+The pin type indicates a physical pin on a microcontroller. It can be used directly for GPIO or as part of a different peripheral (SPI, ADC, etc).
+
+The `NoPin` value can be used in some places where you want to explicitly not use a pin. For example, depending on the chip you could use only SDO or SDI of an SPI peripheral, leaving the other pin unused.
+
+Boards have various pins defined as constants. For example, ATsamd21 based chips (often marketed as "M0") have pin number PB01 defined as `PB01` in the machine package and the Arduino Uno has pin 13 defined as `D13`. However, please note that Arduino pin numbers do not necessarily match the pin numbers as used in TinyGo, therefore you should always use the named constants to refer to a pin if possible.
+
+```go
+type PinMode uint8
+
+const (
+    PinOutput          PinMode = ...
+    PinInput           PinMode = ...
+    PinInputPullup     PinMode = ...
+    PinInputPulldown   PinMode = ... // not always available
+    PinOutputOpenDrain PinMode = ... // not always available
+    PinDisable         PinMode = ... // not always available
+)
+```
+
+These `PinMode` are used to set a pin to various states: as input or output and optionally with a pull resistor (see above in the guide). The values these constants have vary by chip and should be considered implementation details.
+
+Pull-down mode is not always available on the hardware. If it is not available, the `PinInputPulldown` constant is not available resulting in a compile error.
+
+```go
+type PinConfig struct {
+    Mode PinMode
+}
+```
+
+This struct contains options to configure a hardware pin. More options might be added in the future (with appropriate behavior on the zero value), but currently only the `Mode` field is used.
+
+```go
+func (p Pin) Configure(config machine.PinConfig)
+```
+
+Configure a pin, see `PinConfig` and `PinMode` above. `Configure` must be called before any other method may be called.
+
+```go
+func (p Pin) Low()
+func (p Pin) High()
+func (p Pin) Set(state bool)
+```
+
+Set an output pin to low or high. It must have been configured before as an output (`PinOutput`) or the behavior will be undefined. The `Set` method sets the state to low or high depending on the boolean value: `true` means high, `false` means low.
+
+```go
+func (p Pin) Get() bool
+```
+
+Get the input state of a pin. The returned value indicates whether the pin is low or high: `true` means high and `false` means low. The pin must be configured as an input or as an output.
+
+Note that if the pin is left floating (not connected to anything) the returned value is unpredictable and may appear random.
+
+```go
+type PinChange uint8
+
+const (
+    PinRising  PinChange = ... // call callback when the pin goes from low to high
+    PinFalling PinChange = ... // call callback when the pin goes from high to low
+    PinToggle  PinChange = ... // call callback when the pin changes either way
+)
+
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when the pin changes state. The pin should already be configured as an input, including a pull up or down if no external pull is provided. The callback is called in an interrupt handler, which means the code is limited in what it can do: it cannot block and it may not allocate heap memory.
+
+This call will replace a previously set callback on this pin. You can pass `nil` to disable the interrupt. If you do so, the change parameter is ignored and can be set to any value (such as 0).
+
+
+## SPI
+
+```go
+type SPIConfig struct {
+    Frequency uint32
+    SCK       Pin
+    SDO       Pin
+    SDI       Pin
+    LSBFirst  bool
+    Mode      uint8
+}
+```
+
+The `SPIConfig` struct contains the configuration for the SPI peripheral.
+
+  * `Frequency` is the maximum frequency that will be used: for example `1 * MHz` for 1MHz. Depending on chip capabilities, this or a lower frequency will be selected. When not set (or set to 0), the default of 4MHz will be used.
+  * `SCK`, `SDO` and `SDI` are the clock, data out, and data in pins respectively, however support for setting pins other than the default pins may not be supported by a given SPI peripheral. Some chips are flexible and allow the use of any pin, while other boards only allow a limited range of pins or use fixed SCK/SDO/SDI pins. When these pins are left at the zero value, the default for the particular board is used.
+  * `LSBFirst` configures the SPI peripheral to clock out the least significant bit (LSB) first. The default and most commonly used configuration is the most significant bit first (`LSBFirst=false`).
+  * `Mode` is the [SPI mode (CPOL/CPHA) to be used](https://en.wikipedia.org/wiki/Serial_Peripheral_Interface#Clock_polarity_and_phase). Mode 0 is appropriate for most peripheral chips, but other modes may be needed in some cases. Check your peripheral documentation for details.
+      | Mode    | CPOL | CPHA |
+      | ------- | ---- | ---- |
+      | `Mode0` | 0    | 0    |
+      | `Mode1` | 0    | 1    |
+      | `Mode2` | 1    | 0    |
+      | `Mode3` | 1    | 1    |
+
+```go
+type SPI struct {
+    // values are unexported or vary by chip
+}
+
+var (
+    SPI0 = SPI{...}
+    SPI1 = SPI{...}
+)
+```
+
+The `SPI` object refers to a single (hardware) SPI instance. Depending on chip capabilities, various objects such as `SPI0` and perhaps others are defined.
+
+```go
+func (spi SPI) Configure(config SPIConfig) error
+```
+
+The `Configure` call enables and configures the hardware SPI for use, setting the configuration as described in `SPIConfig`. It will return an error when an incorrect configuration is provided (for example, using pins not usable with this SPI instance). See `SPIConfig` for details.
+
+```go
+func (spi SPI) Transfer(b byte) (byte, error)
+```
+
+Transmit and receive a single byte. Due to the nature of the SPI protocol, they happen both at the same time.
+
+Use `Tx` instead of `Transfer` for high performance bulk transfers.
+
+```go
+func (spi SPI) Tx(w, r []byte) error
+```
+
+The `Tx` performs the actual SPI transaction, and return an error if there was an error during the transaction. Because SPI is a synchronous protocol, reading and writing happens at the same time. Therefore, `w` and `r` usually have to be the same length. There are some exceptions:
+
+  * When `r` is nil, the SPI peripheral will only transmit the bytes in `w` and ignore what it receives.
+  * When `w` is nil, the SPI peripheral will only read the given number of bytes and store it in `r`. It will send out a zero byte for each byte that it reads.
+
+Some chips may also support mismatched lengths of `w` and `r`, in which case they will behave like above for the remaining bytes in the byte slice that's the longest of the two.
+
+
+## I2C
+
+```go
+type I2CConfig struct {
+    Frequency uint32
+    SCL       Pin
+    SDA       Pin
+    Mode      I2CMode
+}
+```
+
+The `I2CConfig` struct contains the configuration for the I2C peripheral.
+
+  * `Frequency` can be set to either 100kHz (`100e3`), 400kHz (`400e3`), and sometimes to other values depending on the chip. The zero value defaults to 100kHz.
+  * `SCL` and `SDA` can be set as desired, however support for different pins than the default is limited. Some chips are flexible and allow the use of any pin, while other boards only allow a limited range of pins or use fixed SCL/SDA pins. When both pins are left at the zero value, the default for the particular board is used.
+  * `Mode` is present on peripherals that support I2C target mode.  The default
+  is I2C controller mode, setting `Mode` to `I2CModeTarget` will configure the
+  peripheral as an I2C target.
+```go
+type I2C struct {
+    // values are unexported or vary by chip
+}
+
+var (
+    I2C0 = I2C{...}
+    I2C1 = I2C{...}
+)
+```
+
+The `I2C` object refers to a single (hardware) I2C instance. Depending on chip capabilities, various objects such as `I2C0` and perhaps others are defined.
+
+```go
+func (i2c I2C) Configure(config I2CConfig) error
+```
+
+The `Configure` call enables and configures the hardware I2C for use, setting the pins and frequency. It will return an error when an incorrect configuration is provided (for example, using pins not usable with this I2C instance). See `I2CConfig` for details.
+
+```go
+func (i2c I2C) Tx(addr uint16, w, r []byte) error
+```
+
+_I2C Controller Mode Only_: The `Tx` call performs the actual I2C transaction. It first writes the bytes in `w` to the peripheral device indicated in `addr` and then reads `r` bytes from the peripheral and stores the read bytes in the `r` slice. It returns an error if the transaction failed. Both `w` and `r` can be `nil`.
+
+```go
+func (i2c I2C) Listen(addr uint16) error
+```
+
+_I2C Target Mode Only_: The `Listen` call starts the I2C peripheral listening for I2C transactions sent
+to `addr` by the controller.  The peripheral must have been configured in target
+mode (see `I2CConfig` struct) before `Listen` is called.
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+_I2C Target Mode Only_: The `WaitForEvent` call blocks the current goroutine waiting for an I2C event.  For `I2CReceive` events, the message will be placed in `buf` and return the `count` of bytes received.  Oversize messages (those larger than `buf`) will be truncated.
+
+The underlying peripheral will perform clock stretching, if necessary, in two cases:
+
+  1. A correctly addressed message is received and the application is not blocked on a call to `WaitForEvent`,
+
+  2. The application does not call `Reply` with a single I2C clock cycle for `I2CRequest` events.
+
+Although the I2C target may perform clock stretching, controllers may implement arbitrary timeouts for pending devices.  To avoid timeouts from the perspective a controller, the application should:
+
+  1. Handle the returned event in a timely manner, calling `Reply` if appropriate.
+
+  2. Not have any go routines that may block indefinitely as `WaitForEvent` may yield the CPU to another go routine while waiting for an event.
+
+```go
+func (i2c I2C) Reply(buf []byte) error
+```
+
+_I2C Target Mode Only_: The `Reply` call sends a response to the controller when an `I2CRequest` event is received by the target.
+
+## UART
+
+```go
+type UARTConfig struct {
+    BaudRate uint32
+    TX       Pin
+    RX       Pin
+}
+```
+
+The `UARTConfig` struct contains configuration for the UART peripheral.
+
+  * `BaudRate` is the baud rate of the UART. Common values are 9600 and 115200. Other than that, most chips support multiples of 1200 (2400, 4800, 9600, etc). Support for other baud rates varies by chip, some chips even support high baudrates like 1MHz.
+  * `TX` and `RX` are the transmit and receive pins of the UART. Many chips impose restrictions on which pins can be used, some only support a particular TX and RX pin.
+
+```go
+type UARTParity uint8
+
+const (
+    ParityNone UARTParity = iota
+    ParityEven
+    ParityOdd
+)
+```
+
+Parity is a rarely used checksum feature of UART.
+
+  * `ParityNone` is the default, meaning no parity. It is the most commonly used setting.
+  * `ParityEven` means to expect that the total number of 1 bits sent should be an even number.
+  * `ParityOdd` means to expect that the total number of 1 bits sent should be an odd number.
+
+```go
+type UART struct {
+    // values are unexported or vary by chip
+}
+
+var (
+    UART0 = &UART{...}
+    UART1 = &UART{...}
+)
+```
+
+The `UART` object refers to a single (hardware) UART instance. Depending on chip capabilities, various objects such as `UART0` and perhaps others are defined.
+
+```go
+func (uart UART) Configure(config UARTConfig) error
+```
+
+The `Configure` call enables and configures the hardware UART for use, setting the pins and baud rate. It will return an error when an incorrect configuration is provided (for example, using pins not usable with this UART instance). See `UARTConfig` for details.
+
+Depending on the target configuration, a UART may already be configured if it is the stdout output for the given target. In that case, it is normally configured with a baud rate of 115200.
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+Set the baud rate for the UART. This method is not available on all chips. See `UARTConfig` above for permissible baud rate values.
+
+```go
+func (uart *UART) SetFormat(dataBits, stopBits int, parity UARTParity) error
+```
+
+Set the UART format. The default format (8N1 meaning 8 bits, no parity, and 1 stop bit) is used for almost all external devices, but if you need it this method can be used to override the default.
+
+This method is only available on a limited number of chips.
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Return the number of bytes stored in the receive buffer.
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the receive buffer. This method implements the `io.Reader` interface. It is non-blocking: it will return immediately with `n` set to 0 and `err` set to nil if no data is available.
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the UART receive buffer. If there is no data available in the buffer, it returns an error. You can use `Buffered` to know whether there is data available.
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data to the UART. This method implements the `io.Writer` interface. It blocks until all data is written.
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+Write a single byte to the UART output.
+
+## Watchdog
+
+```go
+type WatchdogConfig struct {
+	TimeoutMillis uint32
+}
+```
+
+The `WatchdogConfig` struct contains configuration for the watchdog peripheral.
+
+  * `TimeoutMillis` is the requested maximum delay between calls to `Update`.
+
+```go
+func (wd *Watchdog) Configure(config WatchdogConfig) error
+```
+Configures the watchdog.
+
+This method should not be called after the watchdog is started and on some platforms attempting to reconfigure after starting the watchdog is explicitly forbidden / will not work.
+
+```go
+func (wd *Watchdog) Start() error
+```
+Starts the watchdog.  After calling this method, `Update` must be called periodically.
+
+```go
+func (wd *Watchdog) Update()
+```
+Updates the watchdog, indicating that the app is healthy.  This method must be called periodically to prevent the CPU from resetting.
+
+## Other
+
+```go
+func CPUFrequency() uint32
+```
+
+Return the current CPU frequency in hertz (for example, 16MHz equals 16_000_000). It is often a fixed value.
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+Not all chips support CPUReset.
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns a byte array containing a unique id (aka Serial Number) specific to this chip.  In some architectures (notably RP2040) the device ID is actually the ID of the flash chip.  The device ID can be useful for identifying specific devices within a family.  There is no guarantee the ID is globally unique.  The size of the ID is chip-family specific with 8 bytes (64 bits) and 16 bytes (128 bits) being common.
+
+Not all chips have a hardware ID.
+
+```go
+func GetRNG() uint32
+```
+
+Return a 32-bit random number from a hardware random number generator. It is often (but not always) a cryptographic random number generator. Check the documentation of the chip to be sure.
+
+Not all chips have a random number generator.
+
+```go
+func ReadTemperature() int32
+```
+
+Read the current die temperature of the chip. The return value is in milli-celsius: to convert to Celsius, divide the returned value by 1000.
+
+Not all chips have a built-in temperature sensor.
diff --git a/content/docs/reference/microcontrollers/_index.md b/content/docs/reference/microcontrollers/_index.md
new file mode 100644
index 00000000..0b249b55
--- /dev/null
+++ b/content/docs/reference/microcontrollers/_index.md
@@ -0,0 +1,57 @@
+---
+title: "Microcontrollers"
+chapter: true
+weight: 3
+description: |
+  Documentation for each microcontroller board supported by TinyGo.
+---
+
+TinyGo lets you run Go directly on microcontrollers.
+
+TinyGo has support for over 100 different boards and devices such as the Arduino Nano33 IoT, Adafruit Circuit Playground Express, BBC micro:bit and more. Click on a board name below to see the what features are supported for the given hardware.
+
+Support for some boards and processor types are more complete than others.
+As of early 2023, boards using the following microcontrollers are
+well-supported:
+
+* [SAMD21](https://www.microchip.com/en-us/product/ATSAMD21G18) based on the
+  ARM Cortex-M0+ processor
+    * Some companies (Adafruit) call these boards the "M0".
+* [SAMD51](https://www.microchip.com/en-us/product/ATSAMD51N19A) based on the
+  ARM Cortex-M4 processor
+    * Some companies call these boards the "M4".
+* [nRF52840](https://www.nordicsemi.com/Products/nRF52840)
+  based on the Arm Cortex-M4F processor
+    * Other nRF microcontrollers (e.g.
+    [nRF52832](https://www.nordicsemi.com/Products/nRF52832),
+    [nRF52833](https://www.nordicsemi.com/Products/nRF52833),
+    [nRF51822](https://www.nordicsemi.com/Products/nRF51822)) are less common
+    but should work well with TinyGo.
+* [RP2040](https://en.wikipedia.org/wiki/RP2040) with dual ARM Cortex-M0+
+  processors (although TinyGo uses only a single core)
+    * The Raspberry Pi Pico is a famous example using this, but there are many
+      other boards using this microcontroller now.
+
+The introductory Arduino boards based on the 8-bit AVR processors work
+relatively well under TinyGo. But they have limited amounts of flash and static
+memory so they support only small applications (e.g. the `fmt` package may
+consume too much flash memory, and goroutines may consume too much static
+memory):
+
+* [ATmega328P](https://www.microchip.com/en-us/product/ATmega328P), used by
+  Arduino Nano, Arduino UNO, etc.
+
+Boards using the Espressif microcontrollers have become popular in IoT
+applications because of their support for WiFi. Unfortunately TinyGo does not
+support WiFi nor Bluetooth on these boards:
+
+* [ESP8266](https://en.wikipedia.org/wiki/ESP8266) based on the Xtensa LX106
+  processor
+* [ESP32](https://en.wikipedia.org/wiki/ESP32) based on the Xtensa LX6
+  processor
+* [ESP32-C3](https://www.espressif.com/en/products/socs/esp32-c3) based on the
+  RISC-V processor
+
+We also give you the ability to add new boards. If your target isn't listed here, please raise an issue in the [issue tracker](https://github.com/tinygo-org/tinygo/issues).
+
+Want to know the details about how it is possible to compile Go for microcontrollers? Check out the [microcontrollers](../../concepts/compiler-internals/microcontrollers/) page in our "Compiler Internals" section.
diff --git a/content/docs/reference/microcontrollers/arduino-mega1280.md b/content/docs/reference/microcontrollers/arduino-mega1280.md
new file mode 100644
index 00000000..8156c98d
--- /dev/null
+++ b/content/docs/reference/microcontrollers/arduino-mega1280.md
@@ -0,0 +1,118 @@
+---
+title: "Arduino Mega 1280"
+weight: 3
+---
+
+The [Arduino Mega 1280](https://www.arduino.cc/en/Main/arduinoBoardMega/) is based on the AVR [ATmega1280](https://www.microchip.com/wwwproducts/en/ATMEGA1280) microcontroller.
+
+Note: the AVR backend of LLVM is still experimental so you may encounter bugs.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | NO  | NO  |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `A0`              | `PF0`        | `ADC0`            |                      |                      |
+| `A1`              | `PF1`        | `ADC1`            |                      |                      |
+| `A2`              | `PF2`        | `ADC2`            |                      |                      |
+| `A3`              | `PF3`        | `ADC3`            |                      |                      |
+| `A4`              | `PF4`        | `ADC4`            |                      |                      |
+| `A5`              | `PF5`        | `ADC5`            |                      |                      |
+| `A6`              | `PF6`        | `ADC6`            |                      |                      |
+| `A7`              | `PF7`        | `ADC7`            |                      |                      |
+| `A8`              | `PK0`        | `ADC8`            |                      |                      |
+| `A9`              | `PK1`        | `ADC9`            |                      |                      |
+| `A10`             | `PK2`        | `ADC10`           |                      |                      |
+| `A11`             | `PK3`        | `ADC11`           |                      |                      |
+| `A12`             | `PK4`        | `ADC12`           |                      |                      |
+| `A13`             | `PK5`        | `ADC13`           |                      |                      |
+| `A14`             | `PK6`        | `ADC14`           |                      |                      |
+| `A15`             | `PK7`        | `ADC15`           |                      |                      |
+| `D0`              | `PE0`        |                   |                      |                      |
+| `D1`              | `PE1`        |                   |                      |                      |
+| `D2`              | `PE4`        |                   |                      | `Timer3` (channel B) |
+| `D3`              | `PE5`        |                   |                      | `Timer3` (channel C) |
+| `D4`              | `PG5`        |                   |                      | `Timer0` (channel B) |
+| `D5`              | `PE3`        |                   |                      | `Timer3` (channel A) |
+| `D6`              | `PH3`        |                   |                      | `Timer4` (channel A) |
+| `D7`              | `PH4`        |                   |                      | `Timer4` (channel B) |
+| `D8`              | `PH5`        |                   |                      | `Timer4` (channel C) |
+| `D9`              | `PH6`        |                   |                      | `Timer0` (channel B) |
+| `D10`             | `PB4`        |                   |                      | `Timer2` (channel A) |
+| `D11`             | `PB5`        |                   |                      | `Timer1` (channel A) |
+| `D12`             | `PB6`        |                   |                      | `Timer1` (channel B) |
+| `D13`             | `PB7`        | `LED`             |                      | `Timer0` (channel A) |
+| `D14`             | `PJ1`        |                   |                      |                      |
+| `D15`             | `PJ0`        |                   |                      |                      |
+| `D16`             | `PH1`        |                   |                      |                      |
+| `D17`             | `PH0`        |                   |                      |                      |
+| `D18`             | `PD3`        |                   |                      |                      |
+| `D19`             | `PD2`        |                   |                      |                      |
+| `D20`             | `PD1`        |                   | `I2C0` (SDA)         |                      |
+| `D21`             | `PD0`        |                   | `I2C0` (SCL)         |                      |
+| `D22`             | `PA0`        |                   |                      |                      |
+| `D23`             | `PA1`        |                   |                      |                      |
+| `D24`             | `PA2`        |                   |                      |                      |
+| `D25`             | `PA3`        |                   |                      |                      |
+| `D26`             | `PA4`        |                   |                      |                      |
+| `D27`             | `PA5`        |                   |                      |                      |
+| `D28`             | `PA6`        |                   |                      |                      |
+| `D29`             | `PA7`        |                   |                      |                      |
+| `D30`             | `PC7`        |                   |                      |                      |
+| `D31`             | `PC6`        |                   |                      |                      |
+| `D32`             | `PC5`        |                   |                      |                      |
+| `D33`             | `PC4`        |                   |                      |                      |
+| `D34`             | `PC3`        |                   |                      |                      |
+| `D35`             | `PC2`        |                   |                      |                      |
+| `D36`             | `PC1`        |                   |                      |                      |
+| `D37`             | `PC0`        |                   |                      |                      |
+| `D38`             | `PD7`        |                   |                      |                      |
+| `D39`             | `PG2`        |                   |                      |                      |
+| `D40`             | `PG1`        |                   |                      |                      |
+| `D41`             | `PG0`        |                   |                      |                      |
+| `D42`             | `PL7`        |                   |                      |                      |
+| `D43`             | `PL6`        |                   |                      |                      |
+| `D44`             | `PL5`        |                   |                      | `Timer5` (channel C) |
+| `D45`             | `PL4`        |                   |                      | `Timer5` (channel B) |
+| `D46`             | `PL3`        |                   |                      | `Timer5` (channel A) |
+| `D47`             | `PL2`        |                   |                      |                      |
+| `D48`             | `PL1`        |                   |                      |                      |
+| `D49`             | `PL0`        |                   |                      |                      |
+| `D50`             | `PB3`        |                   |                      |                      |
+| `D51`             | `PB2`        |                   |                      |                      |
+| `D52`             | `PB1`        |                   |                      |                      |
+| `D53`             | `PB0`        |                   |                      |                      |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Arduino Mega 1280](../machine/arduino-mega1280)
+
+## Installing dependencies
+
+The Arduino Mega 1280 needs a few extra dependencies to work, for example, if you get an error like this:
+
+```text
+/bin/sh: 1: avrdude: not found
+```
+
+To fix this, see the installation guide for [Linux](../../../../getting-started/install/linux/#avr-eg-arduino-uno-2) and for [macOS](../../../../getting-started/install/macos/#avr-eg-arduino-uno-2).
+
+## Flashing
+
+### AVRDude
+
+Programs are loaded onto the Arduino Mega 1280 using the `avrdude` command line utility program. You must install this program before you will be able to flash the Arduino Uno board with your TinyGo code.
+
+- Plug your Arduino Uno into your computer's USB port.
+- Build and flash your TinyGo program using `tinygo flash -target arduino-mega1280 /path/to/code`
diff --git a/content/docs/reference/microcontrollers/arduino-mega2560.md b/content/docs/reference/microcontrollers/arduino-mega2560.md
new file mode 100644
index 00000000..0d549da2
--- /dev/null
+++ b/content/docs/reference/microcontrollers/arduino-mega2560.md
@@ -0,0 +1,118 @@
+---
+title: "Arduino Mega 2560"
+weight: 3
+---
+
+The [Arduino Mega 2560](https://store.arduino.cc/arduino-mega-2560-rev3) is based on the AVR [ATmega2560](https://www.microchip.com/wwwproducts/en/ATmega2560) microcontroller.
+
+Note: the AVR backend of LLVM is still experimental so you may encounter bugs.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | Not yet |
+| USBDevice | NO  | NO  |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `A0`              | `PF0`        | `ADC0`            |
+| `A1`              | `PF1`        | `ADC1`            |
+| `A2`              | `PF2`        | `ADC2`            |
+| `A3`              | `PF3`        | `ADC3`            |
+| `A4`              | `PF4`        | `ADC4`            |
+| `A5`              | `PF5`        | `ADC5`            |
+| `A6`              | `PF6`        | `ADC6`            |
+| `A7`              | `PF7`        | `ADC7`            |
+| `A8`              | `PK0`        | `ADC8`            |
+| `A9`              | `PK1`        | `ADC9`            |
+| `A10`             | `PK2`        | `ADC10`           |
+| `A11`             | `PK3`        | `ADC11`           |
+| `A12`             | `PK4`        | `ADC12`           |
+| `A13`             | `PK5`        | `ADC13`           |
+| `A14`             | `PK6`        | `ADC14`           |
+| `A15`             | `PK7`        | `ADC15`           |
+| `D0`              | `PE0`        | `UART_RX_PIN`, `UART0_RX_PIN` |
+| `D1`              | `PE1`        | `UART_TX_PIN`, `UART0_TX_PIN` |
+| `D2`              | `PE4`        |                   |
+| `D3`              | `PE5`        |                   |
+| `D4`              | `PG5`        |                   |
+| `D5`              | `PE3`        |                   |
+| `D6`              | `PH3`        |                   |
+| `D7`              | `PH4`        |                   |
+| `D8`              | `PH5`        |                   |
+| `D9`              | `PH6`        |                   |
+| `D10`             | `PB4`        |                   |
+| `D11`             | `PB5`        |                   |
+| `D12`             | `PB6`        |                   |
+| `D13`             | `PB7`        | `LED`             |
+| `D14`             | `PJ1`        | `UART3_TX_PIN`    |
+| `D15`             | `PJ0`        | `UART3_RX_PIN`    |
+| `D16`             | `PH1`        | `UART2_TX_PIN`    |
+| `D17`             | `PH0`        | `UART2_RX_PIN`    |
+| `D18`             | `PD3`        | `UART1_TX_PIN`    |
+| `D19`             | `PD2`        | `UART1_RX_PIN`    |
+| `D20`             | `PD1`        |                   |
+| `D21`             | `PD0`        |                   |
+| `D22`             | `PA0`        |                   |
+| `D23`             | `PA1`        |                   |
+| `D24`             | `PA2`        |                   |
+| `D25`             | `PA3`        |                   |
+| `D26`             | `PA4`        |                   |
+| `D27`             | `PA5`        |                   |
+| `D28`             | `PA6`        |                   |
+| `D29`             | `PA7`        |                   |
+| `D30`             | `PC7`        |                   |
+| `D31`             | `PC6`        |                   |
+| `D32`             | `PC5`        |                   |
+| `D33`             | `PC4`        |                   |
+| `D34`             | `PC3`        |                   |
+| `D35`             | `PC2`        |                   |
+| `D36`             | `PC1`        |                   |
+| `D37`             | `PC0`        |                   |
+| `D38`             | `PD7`        |                   |
+| `D39`             | `PG2`        |                   |
+| `D40`             | `PG1`        |                   |
+| `D41`             | `PG0`        |                   |
+| `D42`             | `PL7`        |                   |
+| `D43`             | `PL6`        |                   |
+| `D44`             | `PL5`        |                   |
+| `D45`             | `PL4`        |                   |
+| `D46`             | `PL3`        |                   |
+| `D47`             | `PL2`        |                   |
+| `D48`             | `PL1`        |                   |
+| `D49`             | `PL0`        |                   |
+| `D50`             | `PB3`        |                   |
+| `D51`             | `PB2`        |                   |
+| `D52`             | `PB1`        |                   |
+| `D53`             | `PB0`        |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Arduino Mega 2560](../machine/arduino-mega2560)
+
+## Installing dependencies
+
+The Arduino Mega 2560 needs a few extra dependencies to work, for example, if you get an error like this:
+
+```text
+/bin/sh: 1: avrdude: not found
+```
+
+To fix this, see the installation guide for [Linux](../../../../getting-started/install/linux/#avr-eg-arduino-uno-2) and for [macOS](../../../../getting-started/install/macos/#avr-eg-arduino-uno-2).
+
+## Flashing
+
+### AVRDude
+
+Programs are loaded onto the Arduino Mega 2560 using the `avrdude` command line utility program. You must install this program before you will be able to flash the Arduino Uno board with your TinyGo code.
+
+- Plug your Arduino Uno into your computer's USB port.
+- Build and flash your TinyGo program using `tinygo flash -target arduino-mega2560 /path/to/code`
diff --git a/content/docs/reference/microcontrollers/arduino-mkr1000.md b/content/docs/reference/microcontrollers/arduino-mkr1000.md
new file mode 100644
index 00000000..4a7a3fbb
--- /dev/null
+++ b/content/docs/reference/microcontrollers/arduino-mkr1000.md
@@ -0,0 +1,133 @@
+---
+title: "Arduino MKR1000"
+weight: 3
+---
+
+The [Arduino MKR1000](https://store.arduino.cc/arduino-mkr1000-wifi) is a very small ARM development board based on the Microchip [SAMD21](https://www.microchip.com/wwwproducts/en/ATSAMD21G18) family of processors. It also has a NINA-W102 chip onboard which provides an wireless communication abilities based on the popular ESP32 family of wireless chips from Espressif.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- |
+| `D0`              | `PA22`       |                   | `TCC0` (channel 0)   |
+| `D1`              | `PA23`       |                   | `TCC0` (channel 1)   |
+| `D2`              | `PA10`       | `I2S_SCK_PIN`     | `TCC1` (channel 0), `TCC0` (channel 2) |
+| `D3`              | `PA11`       |                   | `TCC1` (channel 1), `TCC0` (channel 3) |
+| `D4`              | `PB10`       |                   | `TCC0` (channel 0)   |
+| `D5`              | `PB11`       |                   | `TCC0` (channel 1)   |
+| `D6`              | `PA20`       | `LED`             | `TCC0` (channel 2)   |
+| `D7`              | `PA21`       |                   | `TCC0` (channel 3)   |
+| `D8`              | `PA16`       | `SPI0_SDO_PIN`    | `TCC2` (channel 0), `TCC0` (channel 2) |
+| `D9`              | `PA17`       | `SPI0_SCK_PIN`    | `TCC2` (channel 1), `TCC0` (channel 3) |
+| `D10`             | `PA19`       | `SPI0_SDI_PIN`    | `TCC0` (channel 3)   |
+| `D11`             | `PA08`       | `SDA_PIN`         | `TCC0` (channel 0), `TCC1` (channel 2) |
+| `D12`             | `PA09`       | `SCL_PIN`         | `TCC0` (channel 1), `TCC1` (channel 3) |
+| `D13`             | `PB23`       | `RX0`, `UART_RX_PIN` |                      |
+| `D14`             | `PB22`       | `TX1`, `UART_TX_PIN` |                      |
+| `A0`              | `PA02`       |                   |                      |
+| `A1`              | `PB02`       |                   |                      |
+| `A2`              | `PB03`       |                   |                      |
+| `A3`              | `PA04`       |                   | `TCC0` (channel 0)   |
+| `A4`              | `PA05`       |                   | `TCC0` (channel 1)   |
+| `A5`              | `PA06`       |                   | `TCC1` (channel 0)   |
+| `A6`              | `PA07`       | `I2S_SDO_PIN`     | `TCC1` (channel 1)   |
+| `USBCDC_DM_PIN`   | `PA24`       |                   | `TCC1` (channel 2)   |
+| `USBCDC_DP_PIN`   | `PA25`       |                   | `TCC1` (channel 3)   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Arduino MKR1000](../machine/arduino-mkr1000)
+
+## Installing BOSSA
+
+In order to flash your TinyGo programs onto the Arduino MKR1000 board, you will need to install the "bossac" command line utility which is part of the [BOSSA command line utilities](https://github.com/shumatech/BOSSA).
+
+### macOS
+
+You can use Homebrew to install the BOSSA command line interface by using the following command:
+
+```shell
+brew install bossa
+```
+
+Or if you  prefer, you can also download the installer from https://github.com/shumatech/BOSSA/releases/download/1.9.1/bossa-1.9.1.dmg
+
+Once you have downloaded it, double click on the .dmg file to perform the installation.
+
+### Linux
+
+On Linux, install from source:
+
+```shell
+sudo apt install libreadline-dev libwxgtk3.0-gtk3-dev
+git clone https://github.com/shumatech/BOSSA.git
+cd BOSSA
+make
+sudo cp bin/bossac /usr/local/bin
+```
+
+### Windows
+
+You can download BOSSA from https://github.com/shumatech/BOSSA/releases/download/1.9.1/bossa-x64-1.9.1.msi
+
+*VERY IMPORTANT*: During the installation, you must choose to install into `c:\Program Files`. The installer might have the wrong path, so edit it to match  `c:\Program Files`.
+
+After the installation, you must add BOSSA to your PATH:
+
+```shell
+set PATH=%PATH%;"c:\Program Files\BOSSA";
+```
+
+Test that you have installed "BOSSA" correctly by running this command:
+
+```shell
+bossac --help
+```
+
+## Flashing
+
+Once you have installed the needed BOSSA command line utility, as in the previous section, you are ready to build and flash code to your Arduino MKR1000 board.
+
+### CLI Flashing
+
+- Plug your Arduino MKR1000 board into your computer's USB port.
+- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the Arduino MKR1000 with the blinky1 example:
+
+    ```shell
+    tinygo flash -target=arduino-mkr1000 examples/blinky1
+    ```
+
+- The Arduino MKR1000 board should restart and then begin running your program.
+
+### Troubleshooting
+
+If you have troubles getting your Arduino MKR1000 board to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the Arduino MKR1000 board ready to receive code.
+- Now try running the `tinygo flash` command as above:
+
+    ```shell
+    tinygo flash -target=arduino-mkr1000 [PATH TO YOUR PROGRAM]
+    ```
+
+Once you have updated your Arduino MKR1000 board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You can use the USB port to the Arduino MKR1000 as a serial port. `UART0` refers to this connection.
+
+For information on how to use the built-in NINA-W102 wireless chip with the default firmware, please see the "wifinina" driver in the TinyGo drivers repository located at [https://github.com/tinygo-org/drivers/tree/release/wifinina](https://github.com/tinygo-org/drivers/tree/release/wifinina).
+
+You can also use the Espressif ESP-AT firmware, although you will need to flash it yourself. Please see the "espat" driver in the TinyGo drivers repository located at [https://github.com/tinygo-org/drivers/tree/release/espat](https://github.com/tinygo-org/drivers/tree/release/espat).
diff --git a/content/docs/reference/microcontrollers/arduino-mkrwifi1010.md b/content/docs/reference/microcontrollers/arduino-mkrwifi1010.md
new file mode 100644
index 00000000..56960faf
--- /dev/null
+++ b/content/docs/reference/microcontrollers/arduino-mkrwifi1010.md
@@ -0,0 +1,140 @@
+---
+title: "Arduino MKR WiFi 1010"
+weight: 3
+---
+
+The [Arduino MKR WiFi 1010](https://store.arduino.cc/usa/mkr-wifi-1010) is a very small ARM development board based on the Microchip [SAMD21](https://www.microchip.com/wwwproducts/en/ATSAMD21G18) family of processors. It also has a NINA-W102 chip onboard which provides an wireless communication abilities based on the popular ESP32 family of wireless chips from Espressif.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `D0`              | `PA22`       | `NINA_TX`         |                      | `TCC0` (channel 0)   |
+| `D1`              | `PA23`       | `NINA_RX`         |                      | `TCC0` (channel 1)   |
+| `D2`              | `PA10`       | `I2S_SCK_PIN`     |                      | `TCC1` (channel 0), `TCC0` (channel 2) |
+| `D3`              | `PA11`       |                   |                      | `TCC1` (channel 1), `TCC0` (channel 3) |
+| `D4`              | `PB10`       |                   |                      | `TCC0` (channel 0)   |
+| `D5`              | `PB11`       |                   |                      | `TCC0` (channel 1)   |
+| `D6`              | `PA20`       | `LED`             |                      | `TCC0` (channel 2)   |
+| `D7`              | `PA21`       |                   |                      | `TCC0` (channel 3)   |
+| `D8`              | `PA16`       | `SPI0_SDO_PIN`    |                      | `TCC2` (channel 0), `TCC0` (channel 2) |
+| `D9`              | `PA17`       | `SPI0_SCK_PIN`    |                      | `TCC2` (channel 1), `TCC0` (channel 3) |
+| `D10`             | `PA19`       | `SPI0_SDI_PIN`    |                      | `TCC0` (channel 3)   |
+| `D11`             | `PA08`       | `SDA_PIN`         | `I2C0` (SDA)         | `TCC0` (channel 0), `TCC1` (channel 2) |
+| `D12`             | `PA09`       | `SCL_PIN`         | `I2C0` (SCL)         | `TCC0` (channel 1), `TCC1` (channel 3) |
+| `D13`             | `PB23`       | `RX0`, `UART_RX_PIN` |                      |                      |
+| `D14`             | `PB22`       | `TX1`, `UART_TX_PIN` |                      |                      |
+| `A0`              | `PA02`       |                   |                      |                      |
+| `A1`              | `PB02`       |                   |                      |                      |
+| `A2`              | `PB03`       |                   |                      |                      |
+| `A3`              | `PA04`       |                   |                      | `TCC0` (channel 0)   |
+| `A4`              | `PA05`       |                   |                      | `TCC0` (channel 1)   |
+| `A5`              | `PA06`       |                   |                      | `TCC1` (channel 0)   |
+| `A6`              | `PA07`       | `I2S_SDO_PIN`     |                      | `TCC1` (channel 1)   |
+| `USBCDC_DM_PIN`   | `PA24`       |                   |                      | `TCC1` (channel 2)   |
+| `USBCDC_DP_PIN`   | `PA25`       |                   |                      | `TCC1` (channel 3)   |
+| `NINA_SDO`        | `PA12`       |                   | `I2C0` (SDA)         | `TCC2` (channel 0), `TCC0` (channel 2) |
+| `NINA_SDI`        | `PA13`       |                   | `I2C0` (SCL)         | `TCC2` (channel 1), `TCC0` (channel 3) |
+| `NINA_CS`         | `PA14`       |                   |                      | `TCC0` (channel 0)   |
+| `NINA_SCK`        | `PA15`       |                   |                      | `TCC0` (channel 1)   |
+| `NINA_GPIO0`      | `PA27`       |                   |                      |                      |
+| `NINA_RESETN`     | `PB08`       |                   |                      |                      |
+| `NINA_ACK`        | `PA28`       |                   |                      |                      |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Arduino MKR WiFi 1010](../machine/arduino-mkrwifi1010)
+
+## Installing BOSSA
+
+In order to flash your TinyGo programs onto the Arduino MKR WiFi 1010 board, you will need to install the "bossac" command line utility which is part of the [BOSSA command line utilities](https://github.com/shumatech/BOSSA).
+
+### macOS
+
+You can use Homebrew to install the BOSSA command line interface by using the following command:
+
+```shell
+brew install bossa
+```
+
+Or if you  prefer, you can also download the installer from https://github.com/shumatech/BOSSA/releases/download/1.9.1/bossa-1.9.1.dmg
+
+Once you have downloaded it, double click on the .dmg file to perform the installation.
+
+### Linux
+
+On Linux, install from source:
+
+```shell
+sudo apt install libreadline-dev libwxgtk3.0-gtk3-dev
+git clone https://github.com/shumatech/BOSSA.git
+cd BOSSA
+make
+sudo cp bin/bossac /usr/local/bin
+```
+
+### Windows
+
+You can download BOSSA from https://github.com/shumatech/BOSSA/releases/download/1.9.1/bossa-x64-1.9.1.msi
+
+*VERY IMPORTANT*: During the installation, you must choose to install into `c:\Program Files`. The installer might have the wrong path, so edit it to match  `c:\Program Files`.
+
+After the installation, you must add BOSSA to your PATH:
+
+```shell
+set PATH=%PATH%;"c:\Program Files\BOSSA";
+```
+
+Test that you have installed "BOSSA" correctly by running this command:
+
+```shell
+bossac --help
+```
+
+## Flashing
+
+Once you have installed the needed BOSSA command line utility, as in the previous section, you are ready to build and flash code to your Arduino MKR WiFi 1010 board.
+
+### CLI Flashing
+
+- Plug your Arduino MKR WiFi 1010 board into your computer's USB port.
+- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the Arduino MKR WiFi 1010 with the blinky1 example:
+
+    ```shell
+    tinygo flash -target=arduino-mkrwifi1010 examples/blinky1
+    ```
+
+- The Arduino MKR WiFi 1010 board should restart and then begin running your program.
+
+### Troubleshooting
+
+If you have troubles getting your Arduino MKR WiFi 1010 board to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the Arduino MKR WiFi 1010 board ready to receive code.
+- Now try running the `tinygo flash` command as above:
+
+    ```shell
+    tinygo flash -target=arduino-mkrwifi1010 [PATH TO YOUR PROGRAM]
+    ```
+
+Once you have updated your Arduino MKR WiFi 1010 board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You can use the USB port to the Arduino MKR WiFi 1010 as a serial port. `UART0` refers to this connection.
+
+For information on how to use the built-in NINA-W102 wireless chip with the default firmware, please see the "wifinina" driver in the TinyGo drivers repository located at [https://github.com/tinygo-org/drivers/tree/release/wifinina](https://github.com/tinygo-org/drivers/tree/release/wifinina).
+
+You can also use the Espressif ESP-AT firmware, although you will need to flash it yourself. Please see the "espat" driver in the TinyGo drivers repository located at [https://github.com/tinygo-org/drivers/tree/release/espat](https://github.com/tinygo-org/drivers/tree/release/espat).
diff --git a/content/docs/reference/microcontrollers/arduino-nano.md b/content/docs/reference/microcontrollers/arduino-nano.md
new file mode 100644
index 00000000..416585f9
--- /dev/null
+++ b/content/docs/reference/microcontrollers/arduino-nano.md
@@ -0,0 +1,68 @@
+---
+title: "Arduino Nano"
+weight: 3
+---
+
+The [Arduino Nano](https://store.arduino.cc/arduino-nano) is based on the AVR [ATmega328p](https://www.microchip.com/wwwproducts/en/ATmega328p) microcontroller.
+
+Note: the AVR backend of LLVM is still experimental so you may encounter bugs.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | NO  | NO  |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `D0`              | `PD0`        | `UART_RX_PIN`     |                      |                      |
+| `D1`              | `PD1`        | `UART_TX_PIN`     |                      |                      |
+| `D2`              | `PD2`        |                   |                      |                      |
+| `D3`              | `PD3`        |                   |                      | `Timer2` (channel B) |
+| `D4`              | `PD4`        |                   |                      |                      |
+| `D5`              | `PD5`        |                   |                      | `Timer0` (channel B) |
+| `D6`              | `PD6`        |                   |                      | `Timer0` (channel A) |
+| `D7`              | `PD7`        |                   |                      |                      |
+| `D8`              | `PB0`        |                   |                      |                      |
+| `D9`              | `PB1`        |                   |                      | `Timer1` (channel A) |
+| `D10`             | `PB2`        |                   |                      | `Timer1` (channel B) |
+| `D11`             | `PB3`        |                   |                      | `Timer2` (channel A) |
+| `D12`             | `PB4`        |                   |                      |                      |
+| `D13`             | `PB5`        | `LED`             |                      |                      |
+| `ADC0`            | `PC0`        |                   |                      |                      |
+| `ADC1`            | `PC1`        |                   |                      |                      |
+| `ADC2`            | `PC2`        |                   |                      |                      |
+| `ADC3`            | `PC3`        |                   |                      |                      |
+| `ADC4`            | `PC4`        |                   | `I2C0` (SDA)         |                      |
+| `ADC5`            | `PC5`        |                   | `I2C0` (SCL)         |                      |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Arduino Nano](../machine/arduino-nano)
+
+## Installing dependencies
+
+The Arduino Nano needs a few extra dependencies to work, for example, if you get an error like this:
+
+```text
+/bin/sh: 1: avrdude: not found
+```
+
+To fix this, see the installation guide for [Linux](../../../../getting-started/install/linux/#avr-eg-arduino-uno-2) and for [macOS](../../../../getting-started/install/macos/#avr-eg-arduino-uno-2).
+
+## Flashing
+
+### AVRDude
+
+Programs are loaded onto the Arduino Uno using the `avrdude` command line utility program. You must install this program before you will be able to flash the Arduino Uno board with your TinyGo code.
+
+- Plug your Arduino Uno into your computer's USB port.
+- Build and flash your TinyGo program using `tinygo flash -target=arduino-nano`
diff --git a/content/docs/reference/microcontrollers/arduino-nano33.md b/content/docs/reference/microcontrollers/arduino-nano33.md
new file mode 100644
index 00000000..b6fbcbc9
--- /dev/null
+++ b/content/docs/reference/microcontrollers/arduino-nano33.md
@@ -0,0 +1,152 @@
+---
+title: "Arduino Nano 33 IoT"
+weight: 3
+---
+
+The [Arduino Nano33 IoT](https://store.arduino.cc/nano-33-iot) is a very small ARM development board based on the Atmel [SAMD21](https://www.microchip.com/wwwproducts/en/ATSAMD21G18) family of processors. It also has a NINA-W102 chip onboard which provides an wireless communication abilities based on the popular ESP32 family of wireless chips from Espressif.
+
+Peripherals: 
+- NINA-W102 chip with [wifinina](https://github.com/tinygo-org/drivers/tree/release/wifinina) firmware (wifi and bluetooth)
+- [lsm6ds3](https://github.com/tinygo-org/drivers/tree/release/lsm6ds3) IMU chip (acceleration, rotation and temperature)
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `RX0`             | `PB23`       |                   |                      |                      |
+| `TX1`             | `PB22`       |                   |                      |                      |
+| `D2`              | `PB10`       |                   |                      | `TCC0` (channel 0)   |
+| `D3`              | `PB11`       |                   |                      | `TCC0` (channel 1)   |
+| `D4`              | `PA07`       |                   |                      | `TCC1` (channel 1)   |
+| `D5`              | `PA05`       |                   |                      | `TCC0` (channel 1)   |
+| `D6`              | `PA04`       |                   |                      | `TCC0` (channel 0)   |
+| `D7`              | `PA06`       |                   |                      | `TCC1` (channel 0)   |
+| `D8`              | `PA18`       |                   |                      | `TCC0` (channel 2)   |
+| `D9`              | `PA20`       |                   |                      | `TCC0` (channel 2)   |
+| `D10`             | `PA21`       |                   |                      | `TCC0` (channel 3)   |
+| `D11`             | `PA16`       | `SPI0_SDO_PIN`    |                      | `TCC2` (channel 0), `TCC0` (channel 2) |
+| `D12`             | `PA19`       | `SPI0_SDI_PIN`    |                      | `TCC0` (channel 3)   |
+| `D13`             | `PA17`       | `LED`, `SPI0_SCK_PIN` |                      | `TCC2` (channel 1), `TCC0` (channel 3) |
+| `A0`              | `PA02`       |                   |                      |                      |
+| `A1`              | `PB02`       |                   |                      |                      |
+| `A2`              | `PA11`       |                   |                      | `TCC1` (channel 1), `TCC0` (channel 3) |
+| `A3`              | `PA10`       | `I2S_SCK_PIN`     |                      | `TCC1` (channel 0), `TCC0` (channel 2) |
+| `A4`              | `PB08`       | `SDA_PIN`         | `I2C0` (SDA)         |                      |
+| `A5`              | `PB09`       | `SCL_PIN`         | `I2C0` (SCL)         |                      |
+| `A6`              | `PA09`       |                   |                      | `TCC0` (channel 1), `TCC1` (channel 3) |
+| `A7`              | `PB03`       |                   |                      |                      |
+| `USBCDC_DM_PIN`   | `PA24`       |                   |                      | `TCC1` (channel 2)   |
+| `USBCDC_DP_PIN`   | `PA25`       |                   |                      | `TCC1` (channel 3)   |
+| `UART_TX_PIN`     | `PA22`       |                   |                      | `TCC0` (channel 0)   |
+| `UART_RX_PIN`     | `PA23`       |                   |                      | `TCC0` (channel 1)   |
+| `NINA_SDO`        | `PA12`       | `NINA_TX`         | `I2C0` (SDA)         | `TCC2` (channel 0), `TCC0` (channel 2) |
+| `NINA_SDI`        | `PA13`       | `NINA_RX`         | `I2C0` (SCL)         | `TCC2` (channel 1), `TCC0` (channel 3) |
+| `NINA_CS`         | `PA14`       | `NINA_RTS`        |                      | `TCC0` (channel 0)   |
+| `NINA_SCK`        | `PA15`       | `NINA_CTS`        |                      | `TCC0` (channel 1)   |
+| `NINA_GPIO0`      | `PA27`       |                   |                      |                      |
+| `NINA_RESETN`     | `PA08`       | `I2S_SDO_PIN`     |                      | `TCC0` (channel 0), `TCC1` (channel 2) |
+| `NINA_ACK`        | `PA28`       |                   |                      |                      |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Arduino Nano33 IoT](../machine/arduino-nano33)
+
+## Pin Mapping
+
+Since the pin labels are located on the other side of the board, here is a picture showing the pin numbering from the front side perspective:
+
+![Arduino Nano33 IoT](../../../../images/nano33pinmap.jpg)
+
+## Installing BOSSA
+
+In order to flash your TinyGo programs onto the Arduino Nano33 IoT board, you will need to install the "bossac" command line utility which is part of the [BOSSA command line utilities](https://github.com/shumatech/BOSSA).
+
+### macOS
+
+You can use Homebrew to install the BOSSA command line interface by using the following command:
+
+```shell
+brew install bossa
+```
+
+Or if you  prefer, you can also download the installer from https://github.com/shumatech/BOSSA/releases/download/1.9.1/bossa-1.9.1.dmg
+
+Once you have downloaded it, double click on the .dmg file to perform the installation.
+
+### Linux
+
+On Linux, install from source:
+
+```shell
+sudo apt install libreadline-dev libwxgtk3.0-gtk3-dev
+git clone https://github.com/shumatech/BOSSA.git
+cd BOSSA
+make
+sudo cp bin/bossac /usr/local/bin
+```
+
+### Windows
+
+You can download BOSSA from https://github.com/shumatech/BOSSA/releases/download/1.9.1/bossa-x64-1.9.1.msi
+
+*VERY IMPORTANT*: During the installation, you must choose to install into `c:\Program Files`. The installer might have the wrong path, so edit it to match  `c:\Program Files`.
+
+After the installation, you must add BOSSA to your PATH:
+
+```shell
+set PATH=%PATH%;"c:\Program Files\BOSSA";
+```
+
+Test that you have installed "BOSSA" correctly by running this command:
+
+```shell
+bossac --help
+```
+
+## Flashing
+
+Once you have installed the needed BOSSA command line utility, as in the previous section, you are ready to build and flash code to your Arduino Nano33 IoT board.
+
+### CLI Flashing
+
+- Plug your Arduino Nano33 IoT board into your computer's USB port.
+- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the Arduino Nano33 IoT with the blinky1 example:
+
+    ```shell
+    tinygo flash -target=arduino-nano33 examples/blinky1
+    ```
+
+- The Arduino Nano33 IoT board should restart and then begin running your program.
+
+### Troubleshooting
+
+If you have troubles getting your Arduino Nano33 IoTboard to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the Arduino Nano33 IoT board ready to receive code.
+- Now try running the `tinygo flash` command as above:
+
+    ```shell
+    tinygo flash -target=arduino-nano33 [PATH TO YOUR PROGRAM]
+    ```
+
+Once you have updated your Arduino Nano33 IoT board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You can use the USB port to the Arduino Nano33 IoT as a serial port. `UART0` refers to this connection.
+
+For information on how to use the built-in NINA-W102 wireless chip with the default firmware, please see the "wifinina" driver in the TinyGo drivers repository located at [https://github.com/tinygo-org/drivers/tree/release/wifinina](https://github.com/tinygo-org/drivers/tree/release/wifinina).
+
+You can also use the Espressif ESP-AT firmware, although you will need to flash it yourself. Please see the "espat" driver in the TinyGo drivers repository located at [https://github.com/tinygo-org/drivers/tree/release/espat](https://github.com/tinygo-org/drivers/tree/release/espat).
diff --git a/content/docs/reference/microcontrollers/arduino-zero.md b/content/docs/reference/microcontrollers/arduino-zero.md
new file mode 100644
index 00000000..872a47e3
--- /dev/null
+++ b/content/docs/reference/microcontrollers/arduino-zero.md
@@ -0,0 +1,138 @@
+---
+title: "Arduino Zero"
+weight: 3
+---
+
+The [Arduino Zero](https://store.arduino.cc/arduino-zero) is a very small ARM development board based on the Atmel [SAMD21](https://www.microchip.com/wwwproducts/en/ATSAMD21G18) family of processors.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- |
+| `D0`              | `PA11`       | `I2S_WS_PIN`, `UART_RX_PIN` | `TCC1` (channel 1), `TCC0` (channel 3) |
+| `D1`              | `PA10`       | `I2S_SCK_PIN`, `UART_TX_PIN` | `TCC1` (channel 0), `TCC0` (channel 2) |
+| `D2`              | `PA14`       |                   | `TCC0` (channel 0)   |
+| `D3`              | `PA09`       |                   | `TCC0` (channel 1), `TCC1` (channel 3) |
+| `D4`              | `PA08`       |                   | `TCC0` (channel 0), `TCC1` (channel 2) |
+| `D5`              | `PA15`       |                   | `TCC0` (channel 1)   |
+| `D6`              | `PA20`       |                   | `TCC0` (channel 2)   |
+| `D7`              | `PA21`       |                   | `TCC0` (channel 3)   |
+| `D8`              | `PA06`       |                   | `TCC1` (channel 0)   |
+| `D9`              | `PA07`       | `I2S_SDO_PIN`     | `TCC1` (channel 1)   |
+| `D10`             | `PA18`       |                   | `TCC0` (channel 2)   |
+| `D11`             | `PA16`       | `SPI0_SDO_PIN`    | `TCC2` (channel 0), `TCC0` (channel 2) |
+| `D12`             | `PA19`       | `SPI0_SDI_PIN`    | `TCC0` (channel 3)   |
+| `D13`             | `PA17`       | `LED`, `LED1`, `SPI0_SCK_PIN` | `TCC2` (channel 1), `TCC0` (channel 3) |
+| `AREF`            | `PA03`       |                   |                      |
+| `ADC0`            | `PA02`       |                   |                      |
+| `ADC1`            | `PB08`       |                   |                      |
+| `ADC2`            | `PB09`       |                   |                      |
+| `ADC3`            | `PA04`       |                   | `TCC0` (channel 0)   |
+| `ADC4`            | `PA05`       |                   | `TCC0` (channel 1)   |
+| `ADC5`            | `PB02`       |                   |                      |
+| `LED2`            | `PA27`       |                   |                      |
+| `LED3`            | `PB03`       |                   |                      |
+| `SPI1_SDO_PIN`    | `PB10`       |                   | `TCC0` (channel 0)   |
+| `SPI1_SDI_PIN`    | `PA12`       |                   | `TCC2` (channel 0), `TCC0` (channel 2) |
+| `SPI1_SCK_PIN`    | `PB11`       |                   | `TCC0` (channel 1)   |
+| `SDA_PIN`         | `PA22`       |                   | `TCC0` (channel 0)   |
+| `SCL_PIN`         | `PA23`       |                   | `TCC0` (channel 1)   |
+| `USBCDC_DM_PIN`   | `PA24`       |                   | `TCC1` (channel 2)   |
+| `USBCDC_DP_PIN`   | `PA25`       |                   | `TCC1` (channel 3)   |
+| `XIN32`           | `PA00`       |                   | `TCC2` (channel 0)   |
+| `XOUT32`          | `PA01`       |                   | `TCC2` (channel 1)   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Arduino Zero](../machine/arduino-zero)
+
+## Installing BOSSA
+
+In order to flash your TinyGo programs onto the Arduino Zero board, you will need to install the "bossac" command line utility which is part of the [BOSSA command line utilities](https://github.com/shumatech/BOSSA).
+
+### macOS
+
+You can use Homebrew to install the BOSSA command line interface by using the following command:
+
+```shell
+brew install bossa
+```
+
+Or if you  prefer, you can also download the installer from https://github.com/shumatech/BOSSA/releases/download/1.9.1/bossa-1.9.1.dmg
+
+Once you have downloaded it, double click on the .dmg file to perform the installation.
+
+### Linux
+
+On Linux, install from source:
+
+```shell
+sudo apt install libreadline-dev libwxgtk3.0-* 
+git clone https://github.com/shumatech/BOSSA.git
+cd BOSSA
+make
+sudo cp bin/bossac /usr/local/bin
+```
+
+### Windows
+
+You can download BOSSA from https://github.com/shumatech/BOSSA/releases/download/1.9.1/bossa-x64-1.9.1.msi
+
+*VERY IMPORTANT*: During the installation, you much choose to install into `c:\Program Files`. The installer might have the wrong path, so edit it to match  `c:\Program Files`.
+
+After the installation, you must add BOSSA to your PATH:
+
+```shell
+set PATH=%PATH%;"c:\Program Files\BOSSA";
+```
+
+Test that you have installed "BOSSA" correctly by running this command:
+
+```shell
+bossac --help
+```
+
+## Flashing
+
+Once you have installed the needed BOSSA command line utility, as in the previous section, you are ready to build and flash code to your Arduino Zero board.
+
+### CLI Flashing
+
+- Plug your Arduino Zero board into your computer's USB port.
+- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the Arduino Zero with the blinky1 example:
+
+    ```
+    tinygo flash -target=arduino-zero examples/blinky1
+    ```
+
+- The Arduino Zero board should restart and then begin running your program.
+
+
+### Troubleshooting
+
+If you have troubles getting your Arduino Zero board to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the Arduino Zero board ready to receive code.
+- Now try running the `tinygo flash` command as above:
+
+    ```shell
+    tinygo flash -target=arduino-zero [PATH TO YOUR PROGRAM]
+    ```
+
+Once you have updated your Arduino Zero board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You can use the USB port to the Arduino Zero as a serial port. `UART0` refers to this connection.
diff --git a/content/docs/reference/microcontrollers/arduino.md b/content/docs/reference/microcontrollers/arduino.md
new file mode 100644
index 00000000..d0687323
--- /dev/null
+++ b/content/docs/reference/microcontrollers/arduino.md
@@ -0,0 +1,79 @@
+---
+title: "Arduino Uno"
+weight: 3
+---
+
+The [Arduino Uno](https://store.arduino.cc/arduino-uno-rev3) is based on the AVR [ATmega328p](https://www.microchip.com/wwwproducts/en/ATmega328p) microcontroller.
+
+Note: the AVR backend of LLVM is still experimental so you may encounter bugs.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | NO  | NO  |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `D0`              | `PD0`        | `UART_RX_PIN`     |                      |                      |
+| `D1`              | `PD1`        | `UART_TX_PIN`     |                      |                      |
+| `D2`              | `PD2`        |                   |                      |                      |
+| `D3`              | `PD3`        |                   |                      | `Timer2` (channel B) |
+| `D4`              | `PD4`        |                   |                      |                      |
+| `D5`              | `PD5`        |                   |                      | `Timer0` (channel B) |
+| `D6`              | `PD6`        |                   |                      | `Timer0` (channel A) |
+| `D7`              | `PD7`        |                   |                      |                      |
+| `D8`              | `PB0`        |                   |                      |                      |
+| `D9`              | `PB1`        |                   |                      | `Timer1` (channel A) |
+| `D10`             | `PB2`        |                   |                      | `Timer1` (channel B) |
+| `D11`             | `PB3`        |                   |                      | `Timer2` (channel A) |
+| `D12`             | `PB4`        |                   |                      |                      |
+| `D13`             | `PB5`        | `LED`             |                      |                      |
+| `ADC0`            | `PC0`        |                   |                      |                      |
+| `ADC1`            | `PC1`        |                   |                      |                      |
+| `ADC2`            | `PC2`        |                   |                      |                      |
+| `ADC3`            | `PC3`        |                   |                      |                      |
+| `ADC4`            | `PC4`        |                   | `I2C0` (SDA)         |                      |
+| `ADC5`            | `PC5`        |                   | `I2C0` (SCL)         |                      |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Arduino Uno](../machine/arduino)
+
+## Installing dependencies
+
+The Arduino Uno needs a few extra dependencies to work, for example, if you get an error like this:
+
+```text
+/bin/sh: 1: avrdude: not found
+```
+
+To fix this, see the installation guide for [Linux](../../../../getting-started/install/linux/#avr-eg-arduino-uno-2) and for [macOS](../../../../getting-started/install/macos/#avr-eg-arduino-uno-2).
+
+## Flashing
+
+### AVRDude
+
+Programs are loaded onto the Arduino Uno using the `avrdude` command line utility program. You must install this program before you will be able to flash the Arduino Uno board with your TinyGo code.
+
+- Plug your Arduino Uno into your computer's USB port.
+- Build and flash your TinyGo program using `tinygo flash -target arduino /path/to/code`
+
+### Arduino Uno R4 Support and other unsupported Arduino boards
+Currently Arduino Uno R4's are not yet supported. See [this PR](https://github.com/tinygo-org/tinygo/pull/4265) for more details.
+If you're receiving error messages like this 
+```
+Error: programmer is not responding
+Warning: attempt 1 of 10: not in sync: resp=0x00
+```
+when attempting to run 
+```tinygo flash -target=arduino -port=COM5```
+this is likely the cause.
diff --git a/content/docs/reference/microcontrollers/atsame54-xpro.md b/content/docs/reference/microcontrollers/atsame54-xpro.md
new file mode 100644
index 00000000..b0a5d307
--- /dev/null
+++ b/content/docs/reference/microcontrollers/atsame54-xpro.md
@@ -0,0 +1,126 @@
+---
+title: "Microchip SAM E54 Xplained Pro"
+weight: 3
+---
+
+The [Microchip SAM E54 Xplained Pro](https://www.microchip.com/developmenttools/productdetails/atsame54-xpro) is a tiny ARM development board based on the Atmel [ATSAME54P20](https://www.microchip.com/wwwproducts/en/ATSAME54P20A) family of SoC.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `LED`             | `PC18`       | `PDEC_INDEX`, `PIN_LED0` |                      | `TCC0` (channel 2)   |
+| `BUTTON`          | `PB31`       | `PIN_BTN0`        |                      | `TCC4` (channel 1), `TCC0` (channel 7) |
+| `EXT1_PIN3_ADC_P` | `PB04`       |                   |                      |                      |
+| `EXT1_PIN4_ADC_N` | `PB05`       |                   |                      |                      |
+| `EXT1_PIN5_GPIO1` | `PA06`       |                   |                      |                      |
+| `EXT1_PIN6_GPIO2` | `PA07`       |                   |                      |                      |
+| `EXT1_PIN7_PWM_P` | `PB08`       |                   |                      |                      |
+| `EXT1_PIN8_PWM_N` | `PB09`       |                   |                      |                      |
+| `EXT1_PIN9_IRQ`   | `PB07`       | `EXT1_PIN9_GPIO`  |                      |                      |
+| `EXT1_PIN10_SPI_SS_B` | `PA27`       | `EXT1_PIN10_GPIO` |                      |                      |
+| `EXT1_PIN11_TWI_SDA` | `PA22`       | `CAN0_TX`, `PCC_DATA06`, `SDA0_PIN`, `SDA_PIN` | `I2C0` (SDA)         | `TCC1` (channel 6), `TCC0` (channel 2) |
+| `EXT1_PIN12_TWI_SCL` | `PA23`       | `CAN0_RX`, `PCC_DATA07`, `SCL0_PIN`, `SCL_PIN` | `I2C0` (SCL)         | `TCC1` (channel 7), `TCC0` (channel 3) |
+| `EXT1_PIN13_UART_RX` | `PA05`       | `UART_RX_PIN`     |                      |                      |
+| `EXT1_PIN14_UART_TX` | `PA04`       | `UART_TX_PIN`     |                      |                      |
+| `EXT1_PIN15_SPI_SS_A` | `PB28`       | `SPI0_SS_PIN`     |                      | `TCC1` (channel 4)   |
+| `EXT1_PIN16_SPI_SDO` | `PB27`       | `SPI0_SDO_PIN`    |                      | `TCC1` (channel 3)   |
+| `EXT1_PIN17_SPI_SDI` | `PB29`       | `SPI0_SDI_PIN`    |                      | `TCC1` (channel 5)   |
+| `EXT1_PIN18_SPI_SCK` | `PB26`       | `SPI0_SCK_PIN`    |                      | `TCC1` (channel 2)   |
+| `EXT2_PIN3_ADC_P` | `PB00`       |                   |                      |                      |
+| `EXT2_PIN4_ADC_N` | `PA03`       |                   |                      |                      |
+| `EXT2_PIN5_GPIO1` | `PB01`       |                   |                      |                      |
+| `EXT2_PIN6_GPIO2` | `PB06`       |                   |                      |                      |
+| `EXT2_PIN7_PWM_P` | `PB14`       | `PCC_DATA08`      |                      | `TCC4` (channel 0), `TCC0` (channel 2) |
+| `EXT2_PIN8_PWM_N` | `PB15`       | `PCC_DATA09`      |                      | `TCC4` (channel 1), `TCC0` (channel 3) |
+| `EXT2_PIN9_IRQ`   | `PD00`       | `EXT2_PIN9_GPIO`  |                      |                      |
+| `EXT2_PIN10_SPI_SS_B` | `PB02`       | `EXT2_PIN10_GPIO` |                      | `TCC2` (channel 2)   |
+| `EXT2_PIN11_TWI_SDA` | `PD08`       | `EXT3_PIN11_TWI_SDA`, `I2C_SDA`, `PCC_I2C_SDA`, `SDA1_PIN`, `SDA2_PIN`, `SDA_DGI_PIN` | `I2C1` (SDA), `I2C2` (SDA), `I2C3` (SDA) | `TCC0` (channel 1)   |
+| `EXT2_PIN12_TWI_SCL` | `PD09`       | `EXT3_PIN12_TWI_SCL`, `I2C_SCL`, `PCC_I2C_SCL`, `SCL1_PIN`, `SCL2_PIN`, `SCL_DGI_PIN` | `I2C1` (SCL), `I2C2` (SCL), `I2C3` (SCL) | `TCC0` (channel 2)   |
+| `EXT2_PIN13_UART_RX` | `PB17`       | `UART2_RX_PIN`    |                      | `TCC3` (channel 1), `TCC0` (channel 5) |
+| `EXT2_PIN14_UART_TX` | `PB16`       | `UART2_TX_PIN`    |                      | `TCC3` (channel 0), `TCC0` (channel 4) |
+| `EXT2_PIN15_SPI_SS_A` | `PC06`       | `SPI1_SS_PIN`     |                      |                      |
+| `EXT2_PIN16_SPI_SDO` | `PC04`       | `EXT3_PIN16_SPI_SDO`, `SPI1_SDO_PIN`, `SPI2_SDO_PIN`, `SPI_DGI_SDO_PIN` |                      | `TCC0` (channel 0)   |
+| `EXT2_PIN17_SPI_SDI` | `PC07`       | `EXT3_PIN17_SPI_SDI`, `SPI1_SDI_PIN`, `SPI2_SDI_PIN`, `SPI_DGI_SDI_PIN` |                      |                      |
+| `EXT2_PIN18_SPI_SCK` | `PC05`       | `EXT3_PIN18_SPI_SCK`, `SPI1_SCK_PIN`, `SPI2_SCK_PIN`, `SPI_DGI_SCK_PIN` |                      | `TCC0` (channel 1)   |
+| `EXT3_PIN3_ADC_P` | `PC02`       |                   |                      |                      |
+| `EXT3_PIN4_ADC_N` | `PC03`       |                   |                      |                      |
+| `EXT3_PIN5_GPIO1` | `PC01`       |                   |                      |                      |
+| `EXT3_PIN6_GPIO2` | `PC10`       |                   |                      | `TCC0` (channel 0), `TCC1` (channel 4) |
+| `EXT3_PIN7_PWM_P` | `PD10`       |                   |                      | `TCC0` (channel 3)   |
+| `EXT3_PIN8_PWM_N` | `PD11`       |                   |                      | `TCC0` (channel 4)   |
+| `EXT3_PIN9_IRQ`   | `PC30`       | `EXT3_PIN9_GPIO`  |                      |                      |
+| `EXT3_PIN10_SPI_SS_B` | `PC31`       | `EXT3_PIN10_GPIO` |                      |                      |
+| `EXT3_PIN13_UART_RX` | `PC23`       | `UART3_RX_PIN`    |                      | `TCC0` (channel 7)   |
+| `EXT3_PIN14_UART_TX` | `PC22`       | `UART3_TX_PIN`    |                      | `TCC0` (channel 6)   |
+| `EXT3_PIN15_SPI_SS_A` | `PC14`       | `SPI2_SS_PIN`     |                      | `TCC0` (channel 4), `TCC1` (channel 0) |
+| `SD_CARD_MCDA0`   | `PB18`       |                   |                      | `TCC1` (channel 0)   |
+| `SD_CARD_MCDA1`   | `PB19`       |                   |                      | `TCC1` (channel 1)   |
+| `SD_CARD_MCDA2`   | `PB20`       |                   |                      | `TCC1` (channel 2)   |
+| `SD_CARD_MCDA3`   | `PB21`       |                   |                      | `TCC1` (channel 3)   |
+| `SD_CARD_MCCK`    | `PA21`       | `PCC_DATA05`      |                      | `TCC1` (channel 5), `TCC0` (channel 1) |
+| `SD_CARD_MCCDA`   | `PA20`       | `PCC_DATA04`      |                      | `TCC1` (channel 4), `TCC0` (channel 0) |
+| `SD_CARD_DETECT`  | `PD20`       |                   |                      | `TCC1` (channel 0)   |
+| `SD_CARD_PROTECT` | `PD21`       |                   |                      | `TCC1` (channel 1)   |
+| `CAN1_STANDBY`    | `PC13`       | `CAN_STANDBY`     |                      | `TCC0` (channel 3), `TCC1` (channel 7) |
+| `CAN1_TX`         | `PB12`       | `CAN_TX`          |                      | `TCC3` (channel 0), `TCC0` (channel 0) |
+| `CAN1_RX`         | `PB13`       | `CAN_RX`          |                      | `TCC3` (channel 1), `TCC0` (channel 1) |
+| `PDEC_PHASE_A`    | `PC16`       |                   |                      | `TCC0` (channel 0)   |
+| `PDEC_PHASE_B`    | `PC17`       |                   |                      | `TCC0` (channel 1)   |
+| `PCC_VSYNC_DEN1`  | `PA12`       | `ETHERNET_RX1`    |                      | `TCC0` (channel 6), `TCC1` (channel 2) |
+| `PCC_HSYNC_DEN2`  | `PA13`       | `ETHERNET_RX0`    |                      | `TCC0` (channel 7), `TCC1` (channel 3) |
+| `PCC_CLK`         | `PA14`       | `ETHERNET_TXCK`   |                      | `TCC2` (channel 0), `TCC1` (channel 2) |
+| `PCC_XCLK`        | `PA15`       | `ETHERNET_RXER`   |                      | `TCC2` (channel 1), `TCC1` (channel 3) |
+| `PCC_DATA00`      | `PA16`       | `PIN_QT_BUTTON`   | `I2C0` (SDA)         | `TCC1` (channel 0), `TCC0` (channel 4) |
+| `PCC_DATA01`      | `PA17`       | `ETHERNET_TXEN`   | `I2C0` (SCL)         | `TCC1` (channel 1), `TCC0` (channel 5) |
+| `PCC_DATA02`      | `PA18`       | `ETHERNET_TX0`    |                      | `TCC1` (channel 2), `TCC0` (channel 6) |
+| `PCC_DATA03`      | `PA19`       | `ETHERNET_TX1`    |                      | `TCC1` (channel 3), `TCC0` (channel 7) |
+| `PCC_RESET`       | `PC12`       | `ETHERNET_MDIO`   |                      | `TCC0` (channel 2), `TCC1` (channel 6) |
+| `PCC_PWDN`        | `PC11`       | `ETHERNET_MDC`    |                      | `TCC0` (channel 1), `TCC1` (channel 5) |
+| `ETHERNET_RXDV`   | `PC20`       |                   |                      | `TCC0` (channel 4)   |
+| `ETHERNET_INT`    | `PD12`       |                   |                      | `TCC0` (channel 5)   |
+| `ETHERNET_RESET`  | `PC21`       |                   |                      | `TCC0` (channel 5)   |
+| `PIN_ETH_LED`     | `PC15`       |                   |                      | `TCC0` (channel 5), `TCC1` (channel 1) |
+| `PIN_ADC_DAC`     | `PA02`       |                   |                      |                      |
+| `PIN_VBUS_DETECT` | `PC00`       |                   |                      |                      |
+| `PIN_USB_ID`      | `PC19`       |                   |                      | `TCC0` (channel 3)   |
+| `USBCDC_DM_PIN`   | `PA24`       |                   |                      | `TCC2` (channel 2)   |
+| `USBCDC_DP_PIN`   | `PA25`       |                   |                      | `TCC2` (channel 3)   |
+| `UART4_TX_PIN`    | `PB25`       |                   |                      |                      |
+| `UART4_RX_PIN`    | `PB24`       |                   |                      |                      |
+| `SPI_DGI_SS_PIN`  | `PD01`       |                   |                      |                      |
+| `QSPI_SCK`        | `PB10`       |                   |                      | `TCC0` (channel 4), `TCC1` (channel 0) |
+| `QSPI_CS`         | `PB11`       |                   |                      | `TCC0` (channel 5), `TCC1` (channel 1) |
+| `QSPI_DATA0`      | `PA08`       |                   |                      | `TCC0` (channel 0), `TCC1` (channel 4) |
+| `QSPI_DATA1`      | `PA09`       |                   |                      | `TCC0` (channel 1), `TCC1` (channel 5) |
+| `QSPI_DATA2`      | `PA10`       |                   |                      | `TCC0` (channel 2), `TCC1` (channel 6) |
+| `QSPI_DATA3`      | `PA11`       |                   |                      | `TCC0` (channel 3), `TCC1` (channel 7) |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Adafruit SAM E54 Xplained Pro](../machine/atsame54-xpro)
+
+## Flashing
+
+### OpenOCD
+
+Programs are loaded onto the SAM E54 Xplained Pro with the onboard [Atmel EDBG](http://ww1.microchip.com/downloads/en/devicedoc/atmel-42096-microcontrollers-embedded-debugger_user-guide.pdf) hardware programmer, using the `openocd` command line utility program to perform the board flashing. You must install [OpenOCD](http://openocd.org/) before you will be able to flash the SAM E54 Xplained Pro board with your TinyGo code.
+
+- Plug your SAM E54 Xplained Pro into your computer's USB port.
+- Build and flash your TinyGo program using `tinygo flash -target=atsame54-xpro [PATH TO YOUR PROGRAM]`
+
+## Notes
+
+You can use the USB port to the SAM E54 Xplained Pro as a serial port. `UART0` refers to this connection.
diff --git a/content/docs/reference/microcontrollers/badger2040-w.md b/content/docs/reference/microcontrollers/badger2040-w.md
new file mode 100644
index 00000000..e7f00c98
--- /dev/null
+++ b/content/docs/reference/microcontrollers/badger2040-w.md
@@ -0,0 +1,80 @@
+---
+title: "Pimoroni Badger2040-W"
+weight: 3
+---
+
+The [Pimoroni Badger2040-W](https://shop.pimoroni.com/products/badger-2040-w) is a badge with E Ink display based on the [Raspberry Pi Pico W](https://datasheets.raspberrypi.com/picow/pico-w-datasheet.pdf) microcontroller.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `LED`             | `GPIO22`     |                   |                      | `PWM3` (channel A)   |
+| `BUTTON_A`        | `GPIO12`     |                   | `I2C0` (SDA)         | `PWM6` (channel A)   |
+| `BUTTON_B`        | `GPIO13`     |                   | `I2C0` (SCL)         | `PWM6` (channel B)   |
+| `BUTTON_C`        | `GPIO14`     |                   | `I2C1` (SDA)         | `PWM7` (channel A)   |
+| `BUTTON_UP`       | `GPIO15`     |                   | `I2C1` (SCL)         | `PWM7` (channel B)   |
+| `BUTTON_DOWN`     | `GPIO11`     |                   | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `EPD_BUSY_PIN`    | `GPIO26`     | `ADC0`            | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `EPD_RESET_PIN`   | `GPIO21`     |                   | `I2C0` (SCL)         | `PWM2` (channel B)   |
+| `EPD_DC_PIN`      | `GPIO20`     |                   | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `EPD_CS_PIN`      | `GPIO17`     |                   | `I2C0` (SCL)         | `PWM0` (channel B)   |
+| `EPD_SCK_PIN`     | `GPIO18`     | `SPI0_SCK_PIN`    | `I2C1` (SDA)         | `PWM1` (channel A)   |
+| `EPD_SDO_PIN`     | `GPIO19`     | `SPI0_SDO_PIN`    | `I2C1` (SCL)         | `PWM1` (channel B)   |
+| `VBUS_DETECT`     | `GPIO24`     |                   |                      | `PWM4` (channel A)   |
+| `VREF_POWER`      | `GPIO27`     | `ADC1`            | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `VREF_1V24`       | `GPIO28`     | `ADC2`            |                      | `PWM6` (channel A)   |
+| `VBAT_SENSE`      | `GPIO29`     | `BATTERY`, `ADC3` |                      | `PWM6` (channel B)   |
+| `ENABLE_3V3`      | `GPIO10`     |                   | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `RTC_ALARM`       | `GPIO8`      |                   | `I2C0` (SDA)         | `PWM4` (channel A)   |
+| `I2C0_SDA_PIN`    | `GPIO4`      |                   | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `I2C0_SCL_PIN`    | `GPIO5`      |                   | `I2C0` (SCL)         | `PWM2` (channel B)   |
+| `SPI0_SDI_PIN`    | `GPIO16`     |                   | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `UART0_TX_PIN`    | `GPIO0`      | `UART_TX_PIN`     | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `UART0_RX_PIN`    | `GPIO1`      | `UART_RX_PIN`     | `I2C0` (SCL)         | `PWM0` (channel B)   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Pimoroni Badger2040](../machine/badger2040-w)
+
+## Flashing
+
+### UF2
+
+The Badger2040-W comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=badger2040-w [PATH TO YOUR PROGRAM]
+    ```
+
+- The Badger2040-W board should restart and then begin running your program.
+
+### Troubleshooting
+
+Any troubleshooting tips go here.
+
+## Notes
+
+You can use the USB port to the Badger2040-W as a serial port.
+
+The Badger2040-W has an onboard CYW43439 wireless chip for WiFi and Bluetooth communication.
+
+TinyGo has support for the RP2040's on-board Programmable Input/Output (PIO) block.
+
+For more informantion, see [https://github.com/tinygo-org/pio](https://github.com/tinygo-org/pio)
diff --git a/content/docs/reference/microcontrollers/badger2040.md b/content/docs/reference/microcontrollers/badger2040.md
new file mode 100644
index 00000000..dee31cf9
--- /dev/null
+++ b/content/docs/reference/microcontrollers/badger2040.md
@@ -0,0 +1,78 @@
+---
+title: "Pimoroni Badger2040"
+weight: 3
+---
+
+The [Pimoroni Badger2040](https://shop.pimoroni.com/products/badger-2040) is a badge with E Ink display based on the Raspberry Pi [RP2040](https://datasheets.raspberrypi.org/rp2040/rp2040-datasheet.pdf) microcontroller.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `LED`             | `GPIO25`     |                   |                      | `PWM4` (channel B)   |
+| `BUTTON_A`        | `GPIO12`     |                   | `I2C0` (SDA)         | `PWM6` (channel A)   |
+| `BUTTON_B`        | `GPIO13`     |                   | `I2C0` (SCL)         | `PWM6` (channel B)   |
+| `BUTTON_C`        | `GPIO14`     |                   | `I2C1` (SDA)         | `PWM7` (channel A)   |
+| `BUTTON_UP`       | `GPIO15`     |                   | `I2C1` (SCL)         | `PWM7` (channel B)   |
+| `BUTTON_DOWN`     | `GPIO11`     |                   | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `BUTTON_USER`     | `GPIO23`     |                   |                      | `PWM3` (channel B)   |
+| `EPD_BUSY_PIN`    | `GPIO26`     | `ADC0`            | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `EPD_RESET_PIN`   | `GPIO21`     |                   | `I2C0` (SCL)         | `PWM2` (channel B)   |
+| `EPD_DC_PIN`      | `GPIO20`     |                   | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `EPD_CS_PIN`      | `GPIO17`     |                   | `I2C0` (SCL)         | `PWM0` (channel B)   |
+| `EPD_SCK_PIN`     | `GPIO18`     | `SPI0_SCK_PIN`    | `I2C1` (SDA)         | `PWM1` (channel A)   |
+| `EPD_SDO_PIN`     | `GPIO19`     | `SPI0_SDO_PIN`    | `I2C1` (SCL)         | `PWM1` (channel B)   |
+| `VBUS_DETECT`     | `GPIO24`     |                   |                      | `PWM4` (channel A)   |
+| `VREF_POWER`      | `GPIO27`     | `ADC1`            | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `VREF_1V24`       | `GPIO28`     | `ADC2`            |                      | `PWM6` (channel A)   |
+| `VBAT_SENSE`      | `GPIO29`     | `BATTERY`, `ADC3` |                      | `PWM6` (channel B)   |
+| `ENABLE_3V3`      | `GPIO10`     |                   | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `I2C0_SDA_PIN`    | `GPIO4`      |                   | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `I2C0_SCL_PIN`    | `GPIO5`      |                   | `I2C0` (SCL)         | `PWM2` (channel B)   |
+| `SPI0_SDI_PIN`    | `GPIO16`     |                   | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `UART0_TX_PIN`    | `GPIO0`      | `UART_TX_PIN`     | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `UART0_RX_PIN`    | `GPIO1`      | `UART_RX_PIN`     | `I2C0` (SCL)         | `PWM0` (channel B)   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Pimoroni Badger2040](../machine/badger2040)
+
+## Flashing
+
+### UF2
+
+The Badger2040 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=badger2040 [PATH TO YOUR PROGRAM]
+    ```
+
+- The Badger2040 board should restart and then begin running your program.
+
+### Troubleshooting
+
+Any troubleshooting tips go here.
+
+## Notes
+
+You can use the USB port to the Badger2040 as a serial port.
+
+TinyGo has support for the RP2040's on-board Programmable Input/Output (PIO) block.
+
+For more informantion, see [https://github.com/tinygo-org/pio](https://github.com/tinygo-org/pio)
diff --git a/content/docs/reference/microcontrollers/bluepill.md b/content/docs/reference/microcontrollers/bluepill.md
new file mode 100644
index 00000000..c4a8530f
--- /dev/null
+++ b/content/docs/reference/microcontrollers/bluepill.md
@@ -0,0 +1,71 @@
+---
+title: 'ST Micro STM32F103XX "Bluepill"'
+weight: 3
+---
+
+The [Bluepill](http://wiki.stm32duino.com/index.php?title=Blue_Pill) is a popular, ultra-cheap and compact ARM development board based on the ST Micro [STM32F103C8](https://www.st.com/en/microcontrollers/stm32f103c8.html) SoC.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | Not yet |
+| USBDevice | YES | Not yet |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `C13`             | `PC13`       | `LED`             |
+| `C14`             | `PC14`       |                   |
+| `C15`             | `PC15`       |                   |
+| `A0`              | `PA0`        | `ADC0`, `BUTTON`  |
+| `A1`              | `PA1`        | `ADC1`            |
+| `A2`              | `PA2`        | `ADC2`            |
+| `A3`              | `PA3`        | `ADC3`            |
+| `A4`              | `PA4`        | `ADC4`            |
+| `A5`              | `PA5`        | `ADC5`, `SPI0_SCK_PIN` |
+| `A6`              | `PA6`        | `ADC6`, `SPI0_SDI_PIN` |
+| `A7`              | `PA7`        | `ADC7`, `SPI0_SDO_PIN` |
+| `B0`              | `PB0`        | `ADC8`            |
+| `B1`              | `PB1`        | `ADC9`            |
+| `B10`             | `PB10`       |                   |
+| `B11`             | `PB11`       |                   |
+| `B12`             | `PB12`       |                   |
+| `B13`             | `PB13`       |                   |
+| `B14`             | `PB14`       |                   |
+| `B15`             | `PB15`       |                   |
+| `A8`              | `PA8`        |                   |
+| `A9`              | `PA9`        | `UART_TX_PIN`     |
+| `A10`             | `PA10`       | `UART_RX_PIN`     |
+| `A11`             | `PA11`       |                   |
+| `A12`             | `PA12`       |                   |
+| `A13`             | `PA13`       |                   |
+| `A14`             | `PA14`       |                   |
+| `A15`             | `PA15`       |                   |
+| `B3`              | `PB3`        |                   |
+| `B4`              | `PB4`        |                   |
+| `B5`              | `PB5`        |                   |
+| `B6`              | `PB6`        | `UART_ALT_TX_PIN`, `I2C0_SCL_PIN` |
+| `B7`              | `PB7`        | `UART_ALT_RX_PIN`, `I2C0_SDA_PIN` |
+| `B8`              | `PB8`        |                   |
+| `B9`              | `PB9`        |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Bluepill](../machine/bluepill)
+
+## Flashing
+
+### OpenOCD
+
+Programs are loaded onto the Bluepill with a separate hardware programmer such as the [STLink v2](https://www.st.com/en/development-tools/st-link-v2.html) board, using the `openocd` command line utility program to perform the board flashing. You must install [OpenOCD](http://openocd.org/) before you will be able to flash the Bluepill board with your TinyGo code.
+
+- Plug your STLink v2 programmer into your computer's USB port.
+- Plug your Bluepill into the STLink v2 programmer using the Bluepill `SWIO`, `SWCLK`, `3V3` and `GND` pins.
+- Build and flash your TinyGo program using `tinygo flash -target=bluepill`
diff --git a/content/docs/reference/microcontrollers/challenger-rp2040.md b/content/docs/reference/microcontrollers/challenger-rp2040.md
new file mode 100644
index 00000000..1fc59de7
--- /dev/null
+++ b/content/docs/reference/microcontrollers/challenger-rp2040.md
@@ -0,0 +1,81 @@
+---
+title: "iLabs Challenger RP2040 LoRa"
+weight: 3
+---
+
+The [iLabs Challenger RP2040 LoRa](https://ilabs.se/product/challenger-rp2040-lora/) is a tiny development board based on the Raspberry Pi [RP2040](https://datasheets.raspberrypi.org/rp2040/rp2040-datasheet.pdf) microcontroller.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `LED`             | `GPIO24`     | `I2C0_SDA_PIN`    |                      | `PWM4` (channel A)   |
+| `D5`              | `GPIO2`      | `I2C1_SDA_PIN`, `SDA_PIN` | `I2C1` (SDA)         | `PWM1` (channel A)   |
+| `D6`              | `GPIO3`      | `I2C1_SCL_PIN`, `SCL_PIN` | `I2C1` (SCL)         | `PWM1` (channel B)   |
+| `D9`              | `GPIO4`      | `UART1_TX_PIN`    | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `D10`             | `GPIO5`      | `UART1_RX_PIN`    | `I2C0` (SCL)         | `PWM2` (channel B)   |
+| `D11`             | `GPIO6`      |                   | `I2C1` (SDA)         | `PWM3` (channel A)   |
+| `D12`             | `GPIO7`      |                   | `I2C1` (SCL)         | `PWM3` (channel B)   |
+| `D13`             | `GPIO8`      |                   | `I2C0` (SDA)         | `PWM4` (channel A)   |
+| `A0`              | `GPIO26`     | `ADC0`            | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `A1`              | `GPIO27`     | `ADC1`            | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `A2`              | `GPIO28`     | `ADC2`            |                      | `PWM6` (channel A)   |
+| `A3`              | `GPIO29`     | `ADC3`            |                      | `PWM6` (channel B)   |
+| `I2C0_SCL_PIN`    | `GPIO25`     |                   |                      | `PWM4` (channel B)   |
+| `SPI0_SCK_PIN`    | `GPIO22`     |                   |                      | `PWM3` (channel A)   |
+| `SPI0_SDO_PIN`    | `GPIO23`     |                   |                      | `PWM3` (channel B)   |
+| `SPI0_SDI_PIN`    | `GPIO20`     |                   | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `SPI1_SCK_PIN`    | `GPIO10`     | `LORA_SCK`        | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `SPI1_SDO_PIN`    | `GPIO11`     | `LORA_SDO`        | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `SPI1_SDI_PIN`    | `GPIO12`     | `LORA_SDI`        | `I2C0` (SDA)         | `PWM6` (channel A)   |
+| `LORA_CS`         | `GPIO9`      |                   | `I2C0` (SCL)         | `PWM4` (channel B)   |
+| `LORA_RESET`      | `GPIO13`     |                   | `I2C0` (SCL)         | `PWM6` (channel B)   |
+| `LORA_DIO0`       | `GPIO14`     |                   | `I2C1` (SDA)         | `PWM7` (channel A)   |
+| `LORA_DIO1`       | `GPIO15`     |                   | `I2C1` (SCL)         | `PWM7` (channel B)   |
+| `LORA_DIO2`       | `GPIO18`     |                   | `I2C1` (SDA)         | `PWM1` (channel A)   |
+| `UART0_TX_PIN`    | `GPIO16`     | `UART_TX_PIN`     | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `UART0_RX_PIN`    | `GPIO17`     | `UART_RX_PIN`     | `I2C0` (SCL)         | `PWM0` (channel B)   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the iLabs Challenger RP2040 LoRa](../machine/challenger-rp2040)
+
+## Flashing
+
+### UF2
+
+The Challenger RP2040 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=challenger-rp2040 [PATH TO YOUR PROGRAM]
+    ```
+
+- The Challenger RP2040 board should restart and then begin running your program.
+
+### Troubleshooting
+
+Any troubleshooting tips go here.
+
+## Notes
+
+You can use the USB port to the Challenger RP2040 as a serial port.
+
+TinyGo has support for the RP2040's on-board Programmable Input/Output (PIO) block.
+
+For more informantion, see [https://github.com/tinygo-org/pio](https://github.com/tinygo-org/pio)
diff --git a/content/docs/reference/microcontrollers/circuitplay-bluefruit.md b/content/docs/reference/microcontrollers/circuitplay-bluefruit.md
new file mode 100644
index 00000000..4c975038
--- /dev/null
+++ b/content/docs/reference/microcontrollers/circuitplay-bluefruit.md
@@ -0,0 +1,133 @@
+---
+title: "Adafruit Circuit Playground Bluefruit"
+weight: 3
+---
+
+The [Adafruit Circuit Playground Bluefruit](https://www.adafruit.com/product/4333) is small ARM development board based on the Nordic Semiconductor [nrf52840](https://www.nordicsemi.com/eng/Products/nRF52840) processor. It has several built-in devices such as WS2812 "NeoPixel" LEDs, buttons, an accelerometer, and some other sensors.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+| Bluetooth | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `D0`              | `P0_30`      | `A6`, `UART_RX_PIN` |
+| `D1`              | `P0_14`      | `A7`, `UART_TX_PIN` |
+| `D2`              | `P0_05`      | `A5`, `SDA_PIN`   |
+| `D3`              | `P0_04`      | `A4`, `SCL_PIN`   |
+| `D4`              | `P1_02`      | `BUTTONA`, `BUTTON` |
+| `D5`              | `P1_15`      | `BUTTONB`, `BUTTON1` |
+| `D6`              | `P0_02`      | `A1`              |
+| `D7`              | `P1_06`      | `SLIDER`          |
+| `D8`              | `P0_13`      | `NEOPIXELS`, `WS2812` |
+| `D9`              | `P0_29`      | `A2`              |
+| `D10`             | `P0_03`      | `A3`              |
+| `D11`             | `P1_04`      |                   |
+| `D12`             | `P0_26`      |                   |
+| `D13`             | `P1_14`      | `LED`             |
+| `A8`              | `P0_28`      | `LIGHTSENSOR`     |
+| `A9`              | `P0_31`      | `TEMPSENSOR`      |
+| `SDA1_PIN`        | `P1_10`      |                   |
+| `SCL1_PIN`        | `P1_12`      |                   |
+| `SPI0_SCK_PIN`    | `P0_19`      |                   |
+| `SPI0_SDO_PIN`    | `P0_21`      |                   |
+| `SPI0_SDI_PIN`    | `P0_23`      |                   |
+| `PDM_CLK_PIN`     | `P0_17`      |                   |
+| `PDM_DIN_PIN`     | `P0_16`      |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Circuit Playground Bluefruit](../machine/circuitplay-bluefruit)
+
+## Flashing
+
+### UF2
+
+The Circuit Playground Bluefruit comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+**PLEASE NOTE** that for a good experience using TinyGo on your board you must be running version 0.4.1 or above of the UF2 bootloader on the board. For more information, [see below](#updating-the-uf2-bootloader)
+
+### CLI Flashing
+
+- Plug your Circuit Playground Bluefruit into your computer's USB port.
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=circuitplay-bluefruit [PATH TO YOUR PROGRAM]
+    ```
+
+- The Circuit Playground Bluefruit board should restart and then begin running your program.
+
+### Troubleshooting
+
+If you have troubles getting your Circuit Playground Bluefruit board to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the Circuit Playground Bluefruit board ready to receive code.
+- The Circuit Playground Bluefruit board will appear to your computer like a USB drive.
+- Now try running the command:
+
+    ```shell
+    tinygo flash -target=circuitplay-bluefruit [PATH TO YOUR PROGRAM]
+    ```
+
+Once you have updated your Circuit Playground Bluefruit board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You can use the USB port to the Circuit Playground Bluefruit as a serial port. `UART0` refers to this connection.
+
+The Neopixel LED on the Circuit Playground Bluefruit can be accessed using the [WS2812](https://pkg.go.dev/tinygo.org/x/drivers/ws2812) driver via the `D8` pin.
+
+For an example that uses the built-in Neopixel LEDs, take a look at the TinyGo drivers repository located at [https://github.com/tinygo-org/drivers/tree/release/examples](https://github.com/tinygo-org/drivers)
+
+Bluetooth support is now available for the Circuit Playground Bluefruit board. See https://github.com/tinygo-org/bluetooth for more information.
+
+## Updating the UF2 bootloader
+
+This board uses a UF2 bootloader created by Adafruit: https://github.com/adafruit/Adafruit_nRF52_Bootloader
+
+We recommend bootloader version 0.4.1 or above. You can check what version is installed on your board by double-clicking the button on the board to launch the bootloader. When you do this, a USB volume that should automatically be mounted on your computer. Check the file named "INFO_UF2.TXT" on that drive. The bootloader firmware version should be listed in that file, for example:
+
+```
+UF2 Bootloader 0.4.1 lib/nrfx (v2.0.0) lib/tinyusb (0.6.0-272-g4e6aa0d8) lib/uf2 (remotes/origin/configupdate-9-gadbb8c7)
+Model: Adafruit Circuit Playground nRF52840
+Board-ID: nRF52840-CircuitPlayground-revD
+SoftDevice: S140 version 6.1.1
+Date: Jan 19 2021
+```
+
+To update the bootloader, you will need to install the `adafruit-nrfutil` program. 
+
+You can install it by running:
+
+```shell
+pip3 install --user adafruit-nrfutil
+```
+
+Once you have installed the `adafruit-nrfutil` program, download the firmware here: 
+https://github.com/adafruit/Adafruit_nRF52_Bootloader/releases/download/0.4.1/circuitplayground_nrf52840_bootloader-0.4.1.zip
+
+Unzip the files in this zip file and save them to a convenient location. 
+
+Plug in your Circuit Playground Bluefruit board to your computer's USB port.
+
+Now we are ready to update the firmware. Run a command something like the following, adjusting for any difference based on where you have saved the files, and what your serial port is named:
+
+```shell
+ adafruit-nrfutil --verbose dfu serial --package circuitplayground_nrf52840_bootloader-0.4.1_s140_6.1.1.zip -p /dev/ttyACM0 -b 115200 --singlebank --touch 1200
+```
+
+Note that you should be flashing the board using the zip file that was contained within the zip file that you downloaded, NOT the file that you downloaded.
+
+Once you have flashed the board with the `adafruit-nrfutil` it should restart the board with the new bootloader. You only need to do this update once, and then from that point on the new bootloader will be active.
diff --git a/content/docs/reference/microcontrollers/circuitplay-express.md b/content/docs/reference/microcontrollers/circuitplay-express.md
new file mode 100644
index 00000000..91ada6fb
--- /dev/null
+++ b/content/docs/reference/microcontrollers/circuitplay-express.md
@@ -0,0 +1,91 @@
+---
+title: "Adafruit Circuit Playground Express"
+weight: 3
+---
+
+The [Adafruit Circuit Playground Express](https://www.adafruit.com/product/3333) is small ARM development board based on the Atmel [SAMD21](https://www.microchip.com/wwwproducts/en/ATSAMD21G18) family of processors. It has several built-in devices such as WS2812 "NeoPixel" LEDs, buttons, an accelerometer, and some other sensors.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `D0`              | `PB09`       | `A6`, `UART_RX_PIN` |                      |                      |
+| `D1`              | `PB08`       | `A7`, `UART_TX_PIN` |                      |                      |
+| `D2`              | `PB02`       | `A5`, `SDA_PIN`   | `I2C0` (SDA)         |                      |
+| `D3`              | `PB03`       | `A4`, `SCL_PIN`   | `I2C0` (SCL)         |                      |
+| `D4`              | `PA28`       | `BUTTONA`, `BUTTON` |                      |                      |
+| `D5`              | `PA14`       | `BUTTONB`, `BUTTON1` |                      | `TCC0` (channel 0)   |
+| `D6`              | `PA05`       | `A1`              |                      | `TCC0` (channel 1)   |
+| `D7`              | `PA15`       | `SLIDER`          |                      | `TCC0` (channel 1)   |
+| `D8`              | `PB23`       | `NEOPIXELS`, `WS2812` |                      |                      |
+| `D9`              | `PA06`       | `A2`              |                      | `TCC1` (channel 0)   |
+| `D10`             | `PA07`       | `A3`              |                      | `TCC1` (channel 1)   |
+| `D12`             | `PA02`       | `A0`              |                      |                      |
+| `D13`             | `PA17`       | `LED`             | `I2C1` (SCL)         | `TCC2` (channel 1), `TCC0` (channel 3) |
+| `A8`              | `PA11`       | `LIGHTSENSOR`     |                      | `TCC1` (channel 1), `TCC0` (channel 3) |
+| `A9`              | `PA09`       | `TEMPSENSOR`      |                      | `TCC0` (channel 1), `TCC1` (channel 3) |
+| `A10`             | `PA04`       | `PROXIMITY`       |                      | `TCC0` (channel 0)   |
+| `USBCDC_DM_PIN`   | `PA24`       |                   |                      | `TCC1` (channel 2)   |
+| `USBCDC_DP_PIN`   | `PA25`       |                   |                      | `TCC1` (channel 3)   |
+| `SDA1_PIN`        | `PA00`       |                   | `I2C1` (SDA)         | `TCC2` (channel 0)   |
+| `SCL1_PIN`        | `PA01`       |                   | `I2C1` (SCL)         | `TCC2` (channel 1)   |
+| `SPI0_SCK_PIN`    | `PA21`       |                   |                      | `TCC0` (channel 3)   |
+| `SPI0_SDO_PIN`    | `PA20`       |                   |                      | `TCC0` (channel 2)   |
+| `SPI0_SDI_PIN`    | `PA16`       |                   | `I2C1` (SDA)         | `TCC2` (channel 0), `TCC0` (channel 2) |
+| `I2S_SCK_PIN`     | `PA10`       |                   |                      | `TCC1` (channel 0), `TCC0` (channel 2) |
+| `I2S_SDO_PIN`     | `PA08`       |                   |                      | `TCC0` (channel 0), `TCC1` (channel 2) |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Circuit Playground Express](../machine/circuitplay-express)
+
+## Flashing
+
+### UF2
+
+The Circuit Playground Express comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Plug your Circuit Playground Express into your computer's USB port.
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=circuitplay-express [PATH TO YOUR PROGRAM]
+    ```
+
+- The Circuit Playground Express board should restart and then begin running your program.
+
+### Troubleshooting
+
+If you have troubles getting your Circuit Playground Express board to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the Circuit Playground Express board ready to receive code.
+- The Circuit Playground Express board will appear to your computer like a USB drive.
+- Now try running the command:
+
+    ```shell
+    tinygo flash -target=circuitplay-express [PATH TO YOUR PROGRAM]
+    ```
+
+Once you have updated your Circuit Playground Express board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You can use the USB port to the Circuit Playground Express as a serial port. `UART0` refers to this connection.
+
+The Neopixel LED on the Circuit Playground Express can be accessed using the [WS2812](https://pkg.go.dev/tinygo.org/x/drivers/ws2812) driver via the `PB23` pin.
+
+For an example that uses the built-in Neopixel LEDs, take a look at the TinyGo drivers repository located at [https://github.com/tinygo-org/drivers/tree/release/examples](https://github.com/tinygo-org/drivers)
diff --git a/content/docs/reference/microcontrollers/clue.md b/content/docs/reference/microcontrollers/clue.md
new file mode 100644
index 00000000..239a3204
--- /dev/null
+++ b/content/docs/reference/microcontrollers/clue.md
@@ -0,0 +1,147 @@
+---
+title: "Adafruit CLUE"
+weight: 3
+---
+
+The [Adafruit CLUE](https://www.adafruit.com/product/4500) is small ARM development board based on the Nordic Semiconductor [nrf52840](https://www.nordicsemi.com/eng/Products/nRF52840) processor. It has several built-in devices such as WS2812 "NeoPixel" LEDs, buttons, an accelerometer, and some other sensors.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+| Bluetooth | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `D0`              | `P0_04`      | `A2`, `UART_RX_PIN` |
+| `D1`              | `P0_05`      | `A3`, `UART_TX_PIN` |
+| `D2`              | `P0_03`      | `A4`              |
+| `D3`              | `P0_28`      | `A5`              |
+| `D4`              | `P0_02`      | `A6`              |
+| `D5`              | `P1_02`      | `BUTTON_LEFT`     |
+| `D6`              | `P1_09`      |                   |
+| `D7`              | `P0_07`      |                   |
+| `D8`              | `P1_07`      |                   |
+| `D9`              | `P0_27`      |                   |
+| `D10`             | `P0_30`      | `A7`              |
+| `D11`             | `P1_10`      | `BUTTON_RIGHT`    |
+| `D12`             | `P0_31`      | `A0`              |
+| `D13`             | `P0_08`      | `SPI0_SCK_PIN`    |
+| `D14`             | `P0_06`      | `SPI0_SDI_PIN`    |
+| `D15`             | `P0_26`      | `SPI0_SDO_PIN`    |
+| `D16`             | `P0_29`      | `A1`              |
+| `D17`             | `P1_01`      | `LED`, `LED1`     |
+| `D18`             | `P0_16`      | `NEOPIXEL`, `WS2812` |
+| `D19`             | `P0_25`      | `SCL_PIN`         |
+| `D20`             | `P0_24`      | `SDA_PIN`         |
+| `D29`             | `P0_14`      | `TFT_SCK`         |
+| `D30`             | `P0_15`      | `TFT_SDO`         |
+| `D31`             | `P0_12`      | `TFT_CS`          |
+| `D32`             | `P0_13`      | `TFT_DC`          |
+| `D33`             | `P1_03`      | `TFT_RESET`       |
+| `D34`             | `P1_05`      | `TFT_LITE`        |
+| `D35`             | `P0_00`      | `PDM_DAT`         |
+| `D36`             | `P0_01`      | `PDM_CLK`         |
+| `D37`             | `P0_19`      | `QSPI_SCK`        |
+| `D38`             | `P0_20`      | `QSPI_CS`         |
+| `D39`             | `P0_17`      | `QSPI_DATA0`      |
+| `D40`             | `P0_22`      | `QSPI_DATA1`      |
+| `D41`             | `P0_23`      | `QSPI_DATA2`      |
+| `D42`             | `P0_21`      | `QSPI_DATA3`      |
+| `D43`             | `P0_10`      | `LED2`            |
+| `D44`             | `P0_09`      |                   |
+| `D45`             | `P1_06`      |                   |
+| `D46`             | `P1_00`      | `SPEAKER`         |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Adafruit CLUE](../machine/clue)
+
+## Flashing
+
+### UF2
+
+The CLUE comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+**PLEASE NOTE** that for a good experience using TinyGo on your board you must be running version 0.4.1 or above of the UF2 bootloader on the board. For more information, [see below](#updating-the-uf2-bootloader)
+
+### CLI Flashing
+
+- Plug your CLUE into your computer's USB port.
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=clue [PATH TO YOUR PROGRAM]
+    ```
+
+- The CLUE board should restart and then begin running your program.
+
+### Troubleshooting
+
+If you have troubles getting your CLUE board to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the CLUE board ready to receive code.
+- The CLUE board will appear to your computer like a USB drive.
+- Now try running the command:
+
+    ```shell
+    tinygo flash -target=clue [PATH TO YOUR PROGRAM]
+    ```
+
+Once you have updated your CLUE board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You can use the USB port to the CLUE as a serial port. `UART0` refers to this connection.
+
+For an example that uses the built-in Neopixel LEDs, take a look at the TinyGo drivers repository located at [https://github.com/tinygo-org/drivers/tree/release/examples](https://github.com/tinygo-org/drivers)
+
+Bluetooth support is now available for the Adafruit CLUE board. See https://github.com/tinygo-org/bluetooth for more information.
+
+## Updating the UF2 bootloader
+
+This board uses a UF2 bootloader created by Adafruit: https://github.com/adafruit/Adafruit_nRF52_Bootloader
+
+We recommend bootloader version 0.4.1 or above. You can check what version is installed on your board by double-clicking the button on the board to launch the bootloader. When you do this, a USB volume that should automatically be mounted on your computer. Check the file named "INFO_UF2.TXT" on that drive. The bootloader firmware version should be listed in that file, for example:
+
+```
+UF2 Bootloader 0.4.1 lib/nrfx (v2.0.0) lib/tinyusb (0.6.0-272-g4e6aa0d8) lib/uf2 (remotes/origin/configupdate-9-gadbb8c7)
+Model: Adafruit CLUE nRF52840
+Board-ID: nRF52840-CLUE-revA
+SoftDevice: S140 version 6.1.1
+Date: Jan 19 2021
+```
+
+To update the bootloader, you will need to install the `adafruit-nrfutil` program. 
+
+You can install it by running:
+
+```shell
+pip3 install --user adafruit-nrfutil
+```
+
+Once you have installed the `adafruit-nrfutil` program, download the firmware here: 
+https://github.com/adafruit/Adafruit_nRF52_Bootloader/releases/download/0.4.1/clue_nrf52840_bootloader-0.4.1.zip
+
+Unzip the files in this zip file and save them to a convenient location. 
+
+Plug in your board to your computer's USB port.
+
+Now we are ready to update the firmware. Run a command something like the following, adjusting for any difference based on where you have saved the files, and what your serial port is named:
+
+```shell
+ adafruit-nrfutil --verbose dfu serial --package clue_nrf52840_bootloader-0.4.1_s140_6.1.1.zip -p /dev/ttyACM0 -b 115200 --singlebank --touch 1200
+```
+
+Note that you should be flashing the board using the zip file that was contained within the zip file that you downloaded, NOT the file that you downloaded.
+
+Once you have flashed the board with the `adafruit-nrfutil` it should restart the board with the new bootloader. You only need to do this update once, and then from that point on the new bootloader will be active.
diff --git a/content/microcontrollers/esp8266-d1mini.md b/content/docs/reference/microcontrollers/d1mini.md
similarity index 75%
rename from content/microcontrollers/esp8266-d1mini.md
rename to content/docs/reference/microcontrollers/d1mini.md
index 1b8751c6..b47c0a91 100644
--- a/content/microcontrollers/esp8266-d1mini.md
+++ b/content/docs/reference/microcontrollers/d1mini.md
@@ -11,12 +11,29 @@ The [Espressif ESP8266](https://www.espressif.com/en/products/socs/esp8266) d1mi
 | --------- | ------------- | ----- |
 | GPIO      | YES | YES |
 | UART      | YES | YES |
-| SPI      | YES | Not Yet |
-| I2C      | NO (software only) | NO |
-| ADC      | YES | Not Yet |
-| PWM      | YES | Not Yet |
+| SPI       | YES | Not yet |
+| I2C       | NO (software only) | Not yet |
+| ADC       | YES | YES |
+| PWM       | YES | Not yet |
+| USBDevice | NO  | NO  |
 | WiFi      | YES | Not Yet |
 
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `D0`              | `GPIO16`     |                   |
+| `D1`              | `GPIO5`      | `SCL_PIN`         |
+| `D2`              | `GPIO4`      | `SDA_PIN`         |
+| `D3`              | `GPIO0`      |                   |
+| `D4`              | `GPIO2`      | `LED`             |
+| `D5`              | `GPIO14`     | `SPI0_SCK_PIN`    |
+| `D6`              | `GPIO12`     | `SPI0_SDI_PIN`    |
+| `D7`              | `GPIO13`     | `SPI0_SDO_PIN`    |
+| `D8`              | `GPIO15`     | `SPI0_CS0_PIN`    |
+| `UART_TX_PIN`     | `GPIO1`      |                   |
+| `UART_RX_PIN`     | `GPIO3`      |                   |
+
 ## Machine Package Docs
 
 [Documentation for the machine package for the ESP8266 d1mini](../machine/d1mini)
diff --git a/content/microcontrollers/digispark.md b/content/docs/reference/microcontrollers/digispark.md
similarity index 66%
rename from content/microcontrollers/digispark.md
rename to content/docs/reference/microcontrollers/digispark.md
index 40f5e221..f7793c54 100644
--- a/content/microcontrollers/digispark.md
+++ b/content/docs/reference/microcontrollers/digispark.md
@@ -15,10 +15,22 @@ Note: the AVR backend of LLVM is still experimental so you may encounter bugs.
 | --------- | ------------- | ----- |
 | GPIO      | YES | YES |
 | UART      | YES | Not yet |
-| SPI      |  Requires software | Not yet |
-| I2C      | Requires software | Not yet |
-| ADC      | YES | Not yet |
-| PWM      | ? | Not yet |
+| SPI       | Requires software | Not yet |
+| I2C       | Requires software | Not yet |
+| ADC       | YES | YES |
+| PWM       | YES | Not yet |
+| USBDevice | NO  | NO  |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `P0`              | `PB0`        |                   |
+| `P1`              | `PB1`        | `LED`             |
+| `P2`              | `PB2`        |                   |
+| `P3`              | `PB3`        |                   |
+| `P4`              | `PB4`        |                   |
+| `P5`              | `PB5`        |                   |
 
 ## Machine Package Docs
 
diff --git a/content/docs/reference/microcontrollers/esp32-coreboard-v2.md b/content/docs/reference/microcontrollers/esp32-coreboard-v2.md
new file mode 100644
index 00000000..4000bff8
--- /dev/null
+++ b/content/docs/reference/microcontrollers/esp32-coreboard-v2.md
@@ -0,0 +1,122 @@
+---
+title: "ESP32 - Core board"
+weight: 3
+---
+
+The esp32-coreboard-v2 is a development board based on the [Espressif ESP32](https://www.espressif.com/en/products/socs/esp32) a powerful chip that is used on many different board mostly because of the built-in radio that can be used for WiFi or Bluetooth wireless connections.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | Not yet |
+| USBDevice | NO  | NO  |
+| WiFi      | YES | Not Yet |
+| Bluetooth | YES | Not yet |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `CLK`             | `GPIO6`      |                   |
+| `CMD`             | `GPIO11`     |                   |
+| `IO0`             | `GPIO0`      | `PWM1_PIN`        |
+| `IO1`             | `GPIO1`      | `TXD`, `UART_TX_PIN` |
+| `IO2`             | `GPIO2`      | `LED`, `PWM0_PIN` |
+| `IO3`             | `GPIO3`      | `RXD`, `UART_RX_PIN` |
+| `IO4`             | `GPIO4`      | `PWM2_PIN`        |
+| `IO5`             | `GPIO5`      | `SPI0_CS0_PIN`    |
+| `IO9`             | `GPIO9`      | `SD2`, `UART1_TX_PIN` |
+| `IO10`            | `GPIO10`     | `SD3`, `UART1_RX_PIN` |
+| `IO16`            | `GPIO16`     |                   |
+| `IO17`            | `GPIO17`     |                   |
+| `IO18`            | `GPIO18`     | `SPI0_SCK_PIN`    |
+| `IO19`            | `GPIO19`     | `SPI0_SDI_PIN`    |
+| `IO21`            | `GPIO21`     | `SDA_PIN`         |
+| `IO22`            | `GPIO22`     | `SCL_PIN`         |
+| `IO23`            | `GPIO23`     | `SPI0_SDO_PIN`    |
+| `IO25`            | `GPIO25`     |                   |
+| `IO26`            | `GPIO26`     |                   |
+| `IO27`            | `GPIO27`     |                   |
+| `IO32`            | `GPIO32`     |                   |
+| `IO33`            | `GPIO33`     |                   |
+| `IO34`            | `GPIO34`     | `ADC0`            |
+| `IO35`            | `GPIO35`     | `ADC1`            |
+| `IO36`            | `GPIO36`     | `SVP`, `ADC2`     |
+| `IO39`            | `GPIO39`     | `SVN`, `ADC3`     |
+| `SD0`             | `GPIO7`      |                   |
+| `SD1`             | `GPIO8`      |                   |
+| `TCK`             | `GPIO13`     |                   |
+| `TD0`             | `GPIO15`     |                   |
+| `TDI`             | `GPIO12`     |                   |
+| `TMS`             | `GPIO14`     |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the ESP32 Core board v2](../machine/esp32-coreboard-v2)
+
+## Flashing
+
+### CLI Flashing on Linux
+
+You need to install the `esptool` flashing tool:
+
+https://github.com/espressif/esptool#easy-installation
+
+Now you should be able to flash your board as follows:
+
+- Plug your ESP32 board into your computer's USB port.
+- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the ESP32 with the blinky1 example:
+
+    ```
+    tinygo flash -target=esp32-coreboard-v2 -port=/dev/ttyUSB0 examples/blinky1
+    ```
+
+- The ESP32 board should restart and then begin running your program.
+
+### CLI Flashing on macOS
+
+You need to install the `esptool` flashing tool:
+
+https://github.com/espressif/esptool#easy-installation
+
+Now you should be able to flash your board as follows:
+
+- Plug your ESP32 board into your computer's USB port.
+- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the ESP32 with the blinky1 example:
+
+    ```
+    tinygo flash -target=esp32-coreboard-v2 examples/blinky1
+    ```
+
+- The ESP32 board should restart and then begin running your program.
+
+### CLI Flashing on Windows
+
+You need to install the `esptool` flashing tool:
+
+https://github.com/espressif/esptool#easy-installation
+
+Now you should be able to flash your board as follows:
+
+- Plug your ESP32 board into your computer's USB port.
+- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the ESP32 with the blinky1 example:
+
+    ```
+    tinygo flash -target=esp32-coreboard-v2 examples/blinky1
+    ```
+
+- The ESP32 board should restart and then begin running your program.
+
+### Troubleshooting
+
+Goes here
+
+## Notes
+
+Goes here
diff --git a/content/docs/reference/microcontrollers/esp32-mini32.md b/content/docs/reference/microcontrollers/esp32-mini32.md
new file mode 100644
index 00000000..be83380e
--- /dev/null
+++ b/content/docs/reference/microcontrollers/esp32-mini32.md
@@ -0,0 +1,122 @@
+---
+title: "ESP32 - mini32"
+weight: 3
+---
+
+The mini32 is a small development board based on the popular [Espressif ESP32](https://www.espressif.com/en/products/socs/esp32). The ESP32 includes a built-in radio that can be used for WiFi or Bluetooth wireless connections.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | Not yet |
+| USBDevice | NO  | NO  |
+| WiFi      | YES | Not Yet |
+| Bluetooth | YES | Not yet |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `CLK`             | `GPIO6`      |                   |
+| `CMD`             | `GPIO11`     |                   |
+| `IO0`             | `GPIO0`      | `PWM1_PIN`        |
+| `IO1`             | `GPIO1`      | `TXD`, `UART_TX_PIN` |
+| `IO2`             | `GPIO2`      | `LED`, `PWM0_PIN` |
+| `IO3`             | `GPIO3`      | `RXD`, `UART_RX_PIN` |
+| `IO4`             | `GPIO4`      | `PWM2_PIN`        |
+| `IO5`             | `GPIO5`      | `SPI0_CS0_PIN`    |
+| `IO9`             | `GPIO9`      | `SD2`, `UART1_TX_PIN` |
+| `IO10`            | `GPIO10`     | `SD3`, `UART1_RX_PIN` |
+| `IO16`            | `GPIO16`     |                   |
+| `IO17`            | `GPIO17`     |                   |
+| `IO18`            | `GPIO18`     | `SPI0_SCK_PIN`    |
+| `IO19`            | `GPIO19`     | `SPI0_SDI_PIN`    |
+| `IO21`            | `GPIO21`     | `SDA_PIN`         |
+| `IO22`            | `GPIO22`     | `SCL_PIN`         |
+| `IO23`            | `GPIO23`     | `SPI0_SDO_PIN`    |
+| `IO25`            | `GPIO25`     |                   |
+| `IO26`            | `GPIO26`     |                   |
+| `IO27`            | `GPIO27`     |                   |
+| `IO32`            | `GPIO32`     |                   |
+| `IO33`            | `GPIO33`     |                   |
+| `IO34`            | `GPIO34`     | `ADC0`            |
+| `IO35`            | `GPIO35`     | `ADC1`            |
+| `IO36`            | `GPIO36`     | `SVP`, `ADC2`     |
+| `IO39`            | `GPIO39`     | `SVN`, `ADC3`     |
+| `SD0`             | `GPIO7`      |                   |
+| `SD1`             | `GPIO8`      |                   |
+| `TCK`             | `GPIO13`     |                   |
+| `TD0`             | `GPIO15`     |                   |
+| `TDI`             | `GPIO12`     |                   |
+| `TMS`             | `GPIO14`     |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the ESP32-mini32](../machine/esp32-mini32)
+
+## Flashing
+
+### CLI Flashing on Linux
+
+You need to install the `esptool` flashing tool:
+
+https://github.com/espressif/esptool#easy-installation
+
+Now you should be able to flash your board as follows:
+
+- Plug your ESP32 board into your computer's USB port.
+- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the ESP32 with the blinky1 example:
+
+    ```
+    tinygo flash -target=esp32-mini32 -port=/dev/ttyUSB0 examples/blinky1
+    ```
+
+- The ESP32 board should restart and then begin running your program.
+
+### CLI Flashing on macOS
+
+You need to install the `esptool` flashing tool:
+
+https://github.com/espressif/esptool#easy-installation
+
+Now you should be able to flash your board as follows:
+
+- Plug your ESP32 board into your computer's USB port.
+- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the ESP32 with the blinky1 example:
+
+    ```
+    tinygo flash -target=esp32-mini32 examples/blinky1
+    ```
+
+- The ESP32 board should restart and then begin running your program.
+
+### CLI Flashing on Windows
+
+You need to install the `esptool` flashing tool:
+
+https://github.com/espressif/esptool#easy-installation
+
+Now you should be able to flash your board as follows:
+
+- Plug your ESP32 board into your computer's USB port.
+- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the ESP32 with the blinky1 example:
+
+    ```
+    tinygo flash -target=esp32-mini32 examples/blinky1
+    ```
+
+- The ESP32 board should restart and then begin running your program.
+
+### Troubleshooting
+
+Goes here
+
+## Notes
+
+Goes here
diff --git a/content/docs/reference/microcontrollers/feather-m0.md b/content/docs/reference/microcontrollers/feather-m0.md
new file mode 100644
index 00000000..47e0de19
--- /dev/null
+++ b/content/docs/reference/microcontrollers/feather-m0.md
@@ -0,0 +1,88 @@
+---
+title: "Adafruit Feather M0"
+weight: 3
+---
+
+The [Adafruit Feather M0](https://www.adafruit.com/product/3403) is a tiny ARM development board based on the Atmel [ATSAMD21G18](https://www.microchip.com/wwwproducts/en/ATSAMD21G18) family of SoC.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `D0`              | `PA11`       |                   |                      | `TCC1` (channel 1), `TCC0` (channel 3) |
+| `D1`              | `PA10`       | `I2S_SCK_PIN`     |                      | `TCC1` (channel 0), `TCC0` (channel 2) |
+| `D3`              | `PA09`       |                   |                      | `TCC0` (channel 1), `TCC1` (channel 3) |
+| `D4`              | `PA08`       | `I2S_SDO_PIN`     |                      | `TCC0` (channel 0), `TCC1` (channel 2) |
+| `D5`              | `PA15`       |                   |                      | `TCC0` (channel 1)   |
+| `D6`              | `PA20`       |                   |                      | `TCC0` (channel 2)   |
+| `D8`              | `PA06`       |                   |                      | `TCC1` (channel 0)   |
+| `D9`              | `PA07`       |                   |                      | `TCC1` (channel 1)   |
+| `D10`             | `PA18`       | `UART_TX_PIN`     |                      | `TCC0` (channel 2)   |
+| `D11`             | `PA16`       | `UART_RX_PIN`     | `I2C0` (SDA)         | `TCC2` (channel 0), `TCC0` (channel 2) |
+| `D12`             | `PA19`       |                   |                      | `TCC0` (channel 3)   |
+| `D13`             | `PA17`       | `LED`             | `I2C0` (SCL)         | `TCC2` (channel 1), `TCC0` (channel 3) |
+| `A0`              | `PA02`       |                   |                      |                      |
+| `A1`              | `PB08`       |                   |                      |                      |
+| `A2`              | `PB09`       |                   |                      |                      |
+| `A3`              | `PA04`       |                   |                      | `TCC0` (channel 0)   |
+| `A4`              | `PA05`       |                   |                      | `TCC0` (channel 1)   |
+| `A5`              | `PB02`       |                   |                      |                      |
+| `USBCDC_DM_PIN`   | `PA24`       |                   |                      | `TCC1` (channel 2)   |
+| `USBCDC_DP_PIN`   | `PA25`       |                   |                      | `TCC1` (channel 3)   |
+| `SDA_PIN`         | `PA22`       |                   | `I2C0` (SDA)         | `TCC0` (channel 0)   |
+| `SCL_PIN`         | `PA23`       |                   | `I2C0` (SCL)         | `TCC0` (channel 1)   |
+| `SPI0_SCK_PIN`    | `PB11`       |                   |                      | `TCC0` (channel 1)   |
+| `SPI0_SDO_PIN`    | `PB10`       |                   |                      | `TCC0` (channel 0)   |
+| `SPI0_SDI_PIN`    | `PA12`       |                   |                      | `TCC2` (channel 0), `TCC0` (channel 2) |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Adafruit Feather M0](../machine/feather-m0)
+
+## Flashing
+
+### UF2
+
+The Feather M0 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Plug your Feather M0 into your computer's USB port.
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=feather-m0 [PATH TO YOUR PROGRAM]
+    ```
+
+- The Feather M0 board should restart and then begin running your program.
+
+### Troubleshooting
+
+If you have troubles getting your Feather M0 board to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the Feather M0 board ready to receive code.
+- The Feather M0 board will appear to your computer like a USB drive.
+- Now try running the command as above:
+
+
+```shell
+tinygo flash -target=feather-m0 [PATH TO YOUR PROGRAM]
+```
+
+Once you have updated your Feather M0 board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You can use the USB port to the Feather M0 as a serial port. `UART0` refers to this connection.
diff --git a/content/docs/reference/microcontrollers/feather-m4-can.md b/content/docs/reference/microcontrollers/feather-m4-can.md
new file mode 100644
index 00000000..428b6f15
--- /dev/null
+++ b/content/docs/reference/microcontrollers/feather-m4-can.md
@@ -0,0 +1,99 @@
+---
+title: "Adafruit Feather M4 CAN"
+weight: 3
+---
+
+The [Adafruit Feather M4 CAN](https://www.adafruit.com/product/4759) is a tiny ARM development board based on the Atmel [ATSAME51J19](https://www.microchip.com/wwwproducts/en/ATSAME51J19A) family of SoC.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `D0`              | `PB17`       | `UART_RX_PIN`     |                      | `TCC3` (channel 1), `TCC0` (channel 5) |
+| `D1`              | `PB16`       | `UART_TX_PIN`     |                      | `TCC3` (channel 0), `TCC0` (channel 4) |
+| `D4`              | `PA14`       |                   |                      | `TCC2` (channel 0), `TCC1` (channel 2) |
+| `D5`              | `PA16`       |                   |                      | `TCC1` (channel 0), `TCC0` (channel 4) |
+| `D6`              | `PA18`       |                   |                      | `TCC1` (channel 2), `TCC0` (channel 6) |
+| `D7`              | `PB03`       |                   |                      | `TCC2` (channel 3)   |
+| `D8`              | `PB02`       | `NEOPIXELS`, `WS2812` |                      | `TCC2` (channel 2)   |
+| `D9`              | `PA19`       |                   |                      | `TCC1` (channel 3), `TCC0` (channel 7) |
+| `D10`             | `PA20`       |                   |                      | `TCC1` (channel 4), `TCC0` (channel 0) |
+| `D11`             | `PA21`       |                   |                      | `TCC1` (channel 5), `TCC0` (channel 1) |
+| `D12`             | `PA22`       | `CAN0_TX`         |                      | `TCC1` (channel 6), `TCC0` (channel 2) |
+| `D13`             | `PA23`       | `LED`, `CAN0_RX`  |                      | `TCC1` (channel 7), `TCC0` (channel 3) |
+| `D21`             | `PA13`       | `SCL_PIN`         | `I2C0` (SCL)         | `TCC0` (channel 7), `TCC1` (channel 3) |
+| `D22`             | `PA12`       | `SDA_PIN`         | `I2C0` (SDA)         | `TCC0` (channel 6), `TCC1` (channel 2) |
+| `D23`             | `PB22`       | `SPI0_SDI_PIN`    |                      |                      |
+| `D24`             | `PB23`       | `SPI0_SDO_PIN`    |                      |                      |
+| `D25`             | `PA17`       | `SPI0_SCK_PIN`    |                      | `TCC1` (channel 1), `TCC0` (channel 5) |
+| `A0`              | `PA02`       |                   |                      |                      |
+| `A1`              | `PA05`       |                   |                      |                      |
+| `A2`              | `PB08`       |                   |                      |                      |
+| `A3`              | `PB09`       |                   |                      |                      |
+| `A4`              | `PA04`       | `UART2_TX_PIN`    |                      |                      |
+| `A5`              | `PA06`       | `UART2_RX_PIN`    |                      |                      |
+| `USBCDC_DM_PIN`   | `PA24`       |                   |                      | `TCC2` (channel 2)   |
+| `USBCDC_DP_PIN`   | `PA25`       |                   |                      | `TCC2` (channel 3)   |
+| `CAN1_STANDBY`    | `PB12`       | `CAN_STANDBY`, `CAN_S` |                      | `TCC3` (channel 0), `TCC0` (channel 0) |
+| `CAN1_TX`         | `PB14`       | `CAN_TX`          |                      | `TCC4` (channel 0), `TCC0` (channel 2) |
+| `CAN1_RX`         | `PB15`       | `CAN_RX`          |                      | `TCC4` (channel 1), `TCC0` (channel 3) |
+| `BOOST_EN`        | `PB13`       |                   |                      | `TCC3` (channel 1), `TCC0` (channel 1) |
+| `QSPI_SCK`        | `PB10`       |                   |                      | `TCC0` (channel 4), `TCC1` (channel 0) |
+| `QSPI_CS`         | `PB11`       |                   |                      | `TCC0` (channel 5), `TCC1` (channel 1) |
+| `QSPI_DATA0`      | `PA08`       |                   | `I2C0` (SDA)         | `TCC0` (channel 0), `TCC1` (channel 4) |
+| `QSPI_DATA1`      | `PA09`       |                   | `I2C0` (SCL)         | `TCC0` (channel 1), `TCC1` (channel 5) |
+| `QSPI_DATA2`      | `PA10`       |                   |                      | `TCC0` (channel 2), `TCC1` (channel 6) |
+| `QSPI_DATA3`      | `PA11`       |                   |                      | `TCC0` (channel 3), `TCC1` (channel 7) |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Adafruit Feather M4 CAN](../machine/feather-m4-can)
+
+## Flashing
+
+### UF2
+
+The Feather M4 CAN comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Plug your Feather M4 CAN into your computer's USB port.
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=feather-m4-can [PATH TO YOUR PROGRAM]
+    ```
+
+- The Feather M4 CAN board should restart and then begin running your program.
+
+
+### Troubleshooting
+
+If you have troubles getting your Feather M4 CAN board to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the Feather M4 CAN board ready to receive code.
+- The Feather M4 CAN board will appear to your computer like a USB drive.
+- Now try running the command as above:
+
+
+```shell
+tinygo flash -target=feather-m4-can [PATH TO YOUR PROGRAM]
+```
+
+Once you have updated your Feather M4 CAN board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You can use the USB port to the Feather M4 CAN as a serial port. `UART0` refers to this connection.
diff --git a/content/docs/reference/microcontrollers/feather-m4.md b/content/docs/reference/microcontrollers/feather-m4.md
new file mode 100644
index 00000000..aa6a5ccf
--- /dev/null
+++ b/content/docs/reference/microcontrollers/feather-m4.md
@@ -0,0 +1,94 @@
+---
+title: "Adafruit Feather M4"
+weight: 3
+---
+
+The [Adafruit Feather M4](https://www.adafruit.com/product/3857) is a tiny ARM development board based on the Atmel [ATSAMD51J19](https://www.microchip.com/wwwproducts/en/ATSAMD51J19A) family of SoC.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `D0`              | `PB17`       | `UART_RX_PIN`     |                      | `TCC3` (channel 1), `TCC0` (channel 5) |
+| `D1`              | `PB16`       | `UART_TX_PIN`     |                      | `TCC3` (channel 0), `TCC0` (channel 4) |
+| `D4`              | `PA14`       |                   |                      | `TCC2` (channel 0), `TCC1` (channel 2) |
+| `D5`              | `PA16`       |                   |                      | `TCC1` (channel 0), `TCC0` (channel 4) |
+| `D6`              | `PA18`       |                   |                      | `TCC1` (channel 2), `TCC0` (channel 6) |
+| `D8`              | `PB03`       | `WS2812`          |                      | `TCC2` (channel 3)   |
+| `D9`              | `PA19`       |                   |                      | `TCC1` (channel 3), `TCC0` (channel 7) |
+| `D10`             | `PA20`       |                   |                      | `TCC1` (channel 4), `TCC0` (channel 0) |
+| `D11`             | `PA21`       |                   |                      | `TCC1` (channel 5), `TCC0` (channel 1) |
+| `D12`             | `PA22`       |                   |                      | `TCC1` (channel 6), `TCC0` (channel 2) |
+| `D13`             | `PA23`       | `LED`             |                      | `TCC1` (channel 7), `TCC0` (channel 3) |
+| `D21`             | `PA13`       | `SCL_PIN`         | `I2C0` (SCL)         | `TCC0` (channel 7), `TCC1` (channel 3) |
+| `D22`             | `PA12`       | `SDA_PIN`         | `I2C0` (SDA)         | `TCC0` (channel 6), `TCC1` (channel 2) |
+| `D23`             | `PB22`       | `SPI0_SDI_PIN`    |                      |                      |
+| `D24`             | `PB23`       | `SPI0_SDO_PIN`    |                      |                      |
+| `D25`             | `PA17`       | `SPI0_SCK_PIN`    |                      | `TCC1` (channel 1), `TCC0` (channel 5) |
+| `A0`              | `PA02`       |                   |                      |                      |
+| `A1`              | `PA05`       |                   |                      |                      |
+| `A2`              | `PB08`       |                   |                      |                      |
+| `A3`              | `PB09`       |                   |                      |                      |
+| `A4`              | `PA04`       | `UART2_TX_PIN`    |                      |                      |
+| `A5`              | `PA06`       | `UART2_RX_PIN`    |                      |                      |
+| `USBCDC_DM_PIN`   | `PA24`       |                   |                      | `TCC2` (channel 2)   |
+| `USBCDC_DP_PIN`   | `PA25`       |                   |                      | `TCC2` (channel 3)   |
+| `QSPI_SCK`        | `PB10`       |                   |                      | `TCC0` (channel 4), `TCC1` (channel 0) |
+| `QSPI_CS`         | `PB11`       |                   |                      | `TCC0` (channel 5), `TCC1` (channel 1) |
+| `QSPI_DATA0`      | `PA08`       |                   | `I2C0` (SDA)         | `TCC0` (channel 0), `TCC1` (channel 4) |
+| `QSPI_DATA1`      | `PA09`       |                   | `I2C0` (SCL)         | `TCC0` (channel 1), `TCC1` (channel 5) |
+| `QSPI_DATA2`      | `PA10`       |                   |                      | `TCC0` (channel 2), `TCC1` (channel 6) |
+| `QSPI_DATA3`      | `PA11`       |                   |                      | `TCC0` (channel 3), `TCC1` (channel 7) |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Adafruit Feather M4](../machine/feather-m4)
+
+## Flashing
+
+### UF2
+
+The Feather M4 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Plug your Feather M4 into your computer's USB port.
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=feather-m4 [PATH TO YOUR PROGRAM]
+    ```
+
+- The Feather M4 board should restart and then begin running your program.
+
+
+### Troubleshooting
+
+If you have troubles getting your Feather M4 board to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the Feather M4 board ready to receive code.
+- The Feather M4 board will appear to your computer like a USB drive.
+- Now try running the command as above:
+
+
+```shell
+tinygo flash -target=feather-m4 [PATH TO YOUR PROGRAM]
+```
+
+Once you have updated your Feather M4 board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You can use the USB port to the Feather M4 as a serial port. `UART0` refers to this connection.
diff --git a/content/docs/reference/microcontrollers/feather-nrf52840-sense.md b/content/docs/reference/microcontrollers/feather-nrf52840-sense.md
new file mode 100644
index 00000000..67c6c308
--- /dev/null
+++ b/content/docs/reference/microcontrollers/feather-nrf52840-sense.md
@@ -0,0 +1,140 @@
+---
+title: "Adafruit Feather nRF52840 Sense"
+weight: 3
+---
+
+The [Adafruit Feather nRF52840 Sense](https://www.adafruit.com/product/4516) is a small ARM development board based on the Nordic Semiconductor [nrf52840](https://www.nordicsemi.com/eng/Products/nRF52840) processor.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+| Bluetooth | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `D0`              | `P0_25`      | `UART_TX_PIN`     |
+| `D1`              | `P0_24`      | `UART_RX_PIN`     |
+| `D2`              | `P0_10`      |                   |
+| `D3`              | `P1_11`      |                   |
+| `D4`              | `P1_10`      | `LED2`            |
+| `D5`              | `P1_08`      |                   |
+| `D6`              | `P0_07`      |                   |
+| `D7`              | `P1_02`      | `BUTTON`          |
+| `D8`              | `P0_16`      | `NEOPIXEL`, `WS2812` |
+| `D9`              | `P0_26`      |                   |
+| `D10`             | `P0_27`      |                   |
+| `D11`             | `P0_06`      |                   |
+| `D12`             | `P0_08`      |                   |
+| `D13`             | `P1_09`      | `LED`, `LED1`     |
+| `D14`             | `P0_04`      | `A0`              |
+| `D15`             | `P0_05`      | `A1`              |
+| `D16`             | `P0_30`      | `A2`              |
+| `D17`             | `P0_28`      | `A3`              |
+| `D18`             | `P0_02`      | `A4`              |
+| `D19`             | `P0_03`      | `A5`              |
+| `D20`             | `P0_29`      | `A6`              |
+| `D21`             | `P0_31`      | `A7`              |
+| `D22`             | `P0_12`      | `SDA_PIN`         |
+| `D23`             | `P0_11`      | `SCL_PIN`         |
+| `D24`             | `P0_15`      | `SPI0_SDI_PIN`    |
+| `D25`             | `P0_13`      | `SPI0_SDO_PIN`    |
+| `D26`             | `P0_14`      | `SPI0_SCK_PIN`    |
+| `D27`             | `P0_19`      | `QSPI_SCK`        |
+| `D28`             | `P0_20`      | `QSPI_CS`         |
+| `D29`             | `P0_17`      | `QSPI_DATA0`      |
+| `D30`             | `P0_22`      | `QSPI_DATA1`      |
+| `D31`             | `P0_23`      | `QSPI_DATA2`      |
+| `D32`             | `P0_21`      | `QSPI_DATA3`      |
+| `D33`             | `P0_09`      |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Adafruit Feather nRF52840 Sense](../machine/feather-nrf52840-sense)
+
+## Flashing
+
+### UF2
+
+The Adafruit Feather nRF52840 Sense comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+**PLEASE NOTE** that for a good experience using TinyGo on your board you must be running version 0.4.1 or above of the UF2 bootloader on the board. For more information, [see below](#updating-the-uf2-bootloader)
+
+### CLI Flashing
+
+- Plug your Adafruit Feather nRF52840 Sense into your computer's USB port.
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=feather-nrf52840-sense [PATH TO YOUR PROGRAM]
+    ```
+
+- The Adafruit Feather nRF52840 Sense board should restart and then begin running your program.
+
+### Troubleshooting
+
+If you have troubles getting your Adafruit Feather nRF52840 Sense board to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the Adafruit Feather nRF52840 Sense board ready to receive code.
+- The Adafruit Feather nRF52840 Sense board will appear to your computer like a USB drive.
+- Now try running the command:
+
+    ```shell
+    tinygo flash -target=feather-nrf52840-sense [PATH TO YOUR PROGRAM]
+    ```
+
+Once you have updated your Adafruit Feather nRF52840 Sense board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You can use the USB port to the Adafruit Feather nRF52840 Sense as a serial port. `UART0` refers to this connection.
+
+Bluetooth support is now available for the Adafruit Feather nRF52840 Sense board. See https://github.com/tinygo-org/bluetooth for more information.
+
+## Updating the UF2 bootloader
+
+This board uses a UF2 bootloader created by Adafruit: https://github.com/adafruit/Adafruit_nRF52_Bootloader
+
+We recommend bootloader version 0.4.1 or above. You can check what version is installed on your board by double-clicking the button on the board to launch the bootloader. When you do this, a USB volume that should automatically be mounted on your computer. Check the file named "INFO_UF2.TXT" on that drive. The bootloader firmware version should be listed in that file, for example:
+
+```
+UF2 Bootloader 0.4.1 lib/nrfx (v2.0.0) lib/tinyusb (0.6.0-272-g4e6aa0d8) lib/uf2 (remotes/origin/configupdate-9-gadbb8c7)
+Model: Adafruit CLUE nRF52840
+Board-ID: nRF52840-CLUE-revA
+SoftDevice: S140 version 6.1.1
+Date: Jan 19 2021
+```
+
+To update the bootloader, you will need to install the `adafruit-nrfutil` program. 
+
+You can install it by running:
+
+```shell
+pip3 install --user adafruit-nrfutil
+```
+
+Once you have installed the `adafruit-nrfutil` program, download the firmware here: 
+https://github.com/adafruit/Adafruit_nRF52_Bootloader/releases/download/0.4.1/feather_nrf52840_sense_bootloader-0.4.1.zip
+
+Unzip the files in this zip file and save them to a convenient location. 
+
+Plug in your board to your computer's USB port.
+
+Now we are ready to update the firmware. Run a command something like the following, adjusting for any difference based on where you have saved the files, and what your serial port is named:
+
+```shell
+ adafruit-nrfutil --verbose dfu serial --package feather_nrf52840_bootloader-0.4.1_s140_6.1.1.zip -p /dev/ttyACM0 -b 115200 --singlebank --touch 1200
+```
+
+Note that you should be flashing the board using the zip file that was contained within the zip file that you downloaded, NOT the file that you downloaded.
+
+Once you have flashed the board with the `adafruit-nrfutil` it should restart the board with the new bootloader. You only need to do this update once, and then from that point on the new bootloader will be active.
diff --git a/content/docs/reference/microcontrollers/feather-nrf52840.md b/content/docs/reference/microcontrollers/feather-nrf52840.md
new file mode 100644
index 00000000..3ff61ba7
--- /dev/null
+++ b/content/docs/reference/microcontrollers/feather-nrf52840.md
@@ -0,0 +1,140 @@
+---
+title: "Adafruit Feather nRF52840 Express"
+weight: 3
+---
+
+The [Adafruit Feather nRF52840](https://www.adafruit.com/product/4500) is a small ARM development board based on the Nordic Semiconductor [nrf52840](https://www.nordicsemi.com/eng/Products/nRF52840) processor.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+| Bluetooth | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `D0`              | `P0_25`      | `UART_TX_PIN`     |
+| `D1`              | `P0_24`      | `UART_RX_PIN`     |
+| `D2`              | `P0_10`      |                   |
+| `D3`              | `P1_15`      | `LED`, `LED1`     |
+| `D4`              | `P1_10`      | `LED2`            |
+| `D5`              | `P1_08`      |                   |
+| `D6`              | `P0_07`      |                   |
+| `D7`              | `P1_02`      | `BUTTON`          |
+| `D8`              | `P0_16`      | `NEOPIXEL`, `WS2812` |
+| `D9`              | `P0_26`      |                   |
+| `D10`             | `P0_27`      |                   |
+| `D11`             | `P0_06`      |                   |
+| `D12`             | `P0_08`      |                   |
+| `D13`             | `P1_09`      |                   |
+| `D14`             | `P0_04`      | `A0`              |
+| `D15`             | `P0_05`      | `A1`              |
+| `D16`             | `P0_30`      | `A2`              |
+| `D17`             | `P0_28`      | `A3`              |
+| `D18`             | `P0_02`      | `A4`              |
+| `D19`             | `P0_03`      | `A5`              |
+| `D20`             | `P0_29`      | `A6`              |
+| `D21`             | `P0_31`      | `A7`              |
+| `D22`             | `P0_12`      | `SDA_PIN`         |
+| `D23`             | `P0_11`      | `SCL_PIN`         |
+| `D24`             | `P0_15`      | `SPI0_SDI_PIN`    |
+| `D25`             | `P0_13`      | `SPI0_SDO_PIN`    |
+| `D26`             | `P0_14`      | `SPI0_SCK_PIN`    |
+| `D27`             | `P0_19`      | `QSPI_SCK`        |
+| `D28`             | `P0_20`      | `QSPI_CS`         |
+| `D29`             | `P0_17`      | `QSPI_DATA0`      |
+| `D30`             | `P0_22`      | `QSPI_DATA1`      |
+| `D31`             | `P0_23`      | `QSPI_DATA2`      |
+| `D32`             | `P0_21`      | `QSPI_DATA3`      |
+| `D33`             | `P0_09`      |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Adafruit Feather nRF52840](../machine/feather-nrf52840)
+
+## Flashing
+
+### UF2
+
+The Adafruit Feather nRF52840 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+**PLEASE NOTE** that for a good experience using TinyGo on your board you must be running version 0.4.1 or above of the UF2 bootloader on the board. For more information, [see below](#updating-the-uf2-bootloader)
+
+### CLI Flashing
+
+- Plug your Adafruit Feather nRF52840 into your computer's USB port.
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=feather-nrf52840 [PATH TO YOUR PROGRAM]
+    ```
+
+- The Adafruit Feather nRF52840 board should restart and then begin running your program.
+
+### Troubleshooting
+
+If you have troubles getting your Adafruit Feather nRF52840 board to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the Adafruit Feather nRF52840 board ready to receive code.
+- The Adafruit Feather nRF52840 board will appear to your computer like a USB drive.
+- Now try running the command:
+
+    ```shell
+    tinygo flash -target=feather-nrf52840 [PATH TO YOUR PROGRAM]
+    ```
+
+Once you have updated your Adafruit Feather nRF52840 board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You can use the USB port to the Adafruit Feather nRF52840 as a serial port. `UART0` refers to this connection.
+
+Bluetooth support is now available for the Adafruit Feather nRF52840 board. See https://github.com/tinygo-org/bluetooth for more information.
+
+## Updating the UF2 bootloader
+
+This board uses a UF2 bootloader created by Adafruit: https://github.com/adafruit/Adafruit_nRF52_Bootloader
+
+We recommend bootloader version 0.4.1 or above. You can check what version is installed on your board by double-clicking the button on the board to launch the bootloader. When you do this, a USB volume that should automatically be mounted on your computer. Check the file named "INFO_UF2.TXT" on that drive. The bootloader firmware version should be listed in that file, for example:
+
+```
+UF2 Bootloader 0.4.1 lib/nrfx (v2.0.0) lib/tinyusb (0.6.0-272-g4e6aa0d8) lib/uf2 (remotes/origin/configupdate-9-gadbb8c7)
+Model: Adafruit CLUE nRF52840
+Board-ID: nRF52840-CLUE-revA
+SoftDevice: S140 version 6.1.1
+Date: Jan 19 2021
+```
+
+To update the bootloader, you will need to install the `adafruit-nrfutil` program. 
+
+You can install it by running:
+
+```shell
+pip3 install --user adafruit-nrfutil
+```
+
+Once you have installed the `adafruit-nrfutil` program, download the firmware here: 
+https://github.com/adafruit/Adafruit_nRF52_Bootloader/releases/download/0.4.1/feather_nrf52840_express_bootloader-0.4.1.zip
+
+Unzip the files in this zip file and save them to a convenient location. 
+
+Plug in your board to your computer's USB port.
+
+Now we are ready to update the firmware. Run a command something like the following, adjusting for any difference based on where you have saved the files, and what your serial port is named:
+
+```shell
+ adafruit-nrfutil --verbose dfu serial --package feather_nrf52840_bootloader-0.4.1_s140_6.1.1.zip -p /dev/ttyACM0 -b 115200 --singlebank --touch 1200
+```
+
+Note that you should be flashing the board using the zip file that was contained within the zip file that you downloaded, NOT the file that you downloaded.
+
+Once you have flashed the board with the `adafruit-nrfutil` it should restart the board with the new bootloader. You only need to do this update once, and then from that point on the new bootloader will be active.
diff --git a/content/docs/reference/microcontrollers/feather-rp2040.md b/content/docs/reference/microcontrollers/feather-rp2040.md
new file mode 100644
index 00000000..6e5b2978
--- /dev/null
+++ b/content/docs/reference/microcontrollers/feather-rp2040.md
@@ -0,0 +1,76 @@
+---
+title: "Adafruit Feather RP2040"
+weight: 3
+---
+
+The [Adafruit Feather RP2040](https://www.adafruit.com/product/4884) is a tiny development board based on the Raspberry Pi [RP2040](https://datasheets.raspberrypi.org/rp2040/rp2040-datasheet.pdf) microcontroller.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `D4`              | `GPIO6`      |                   | `I2C1` (SDA)         | `PWM3` (channel A)   |
+| `D5`              | `GPIO7`      |                   | `I2C1` (SCL)         | `PWM3` (channel B)   |
+| `D6`              | `GPIO8`      | `UART1_TX_PIN`    | `I2C0` (SDA)         | `PWM4` (channel A)   |
+| `D9`              | `GPIO9`      | `UART1_RX_PIN`    | `I2C0` (SCL)         | `PWM4` (channel B)   |
+| `D10`             | `GPIO10`     | `SPI1_SCK_PIN`    | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `D11`             | `GPIO11`     | `SPI1_SDO_PIN`    | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `D12`             | `GPIO12`     | `SPI1_SDI_PIN`    | `I2C0` (SDA)         | `PWM6` (channel A)   |
+| `D13`             | `GPIO13`     | `LED`             | `I2C0` (SCL)         | `PWM6` (channel B)   |
+| `D24`             | `GPIO24`     | `I2C0_SDA_PIN`    |                      | `PWM4` (channel A)   |
+| `D25`             | `GPIO25`     | `I2C0_SCL_PIN`    |                      | `PWM4` (channel B)   |
+| `A0`              | `GPIO26`     | `ADC0`            | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `A1`              | `GPIO27`     | `ADC1`            | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `A2`              | `GPIO28`     | `ADC2`            |                      | `PWM6` (channel A)   |
+| `A3`              | `GPIO29`     | `ADC3`            |                      | `PWM6` (channel B)   |
+| `I2C1_SDA_PIN`    | `GPIO2`      | `SDA_PIN`         | `I2C1` (SDA)         | `PWM1` (channel A)   |
+| `I2C1_SCL_PIN`    | `GPIO3`      | `SCL_PIN`         | `I2C1` (SCL)         | `PWM1` (channel B)   |
+| `SPI0_SCK_PIN`    | `GPIO18`     |                   | `I2C1` (SDA)         | `PWM1` (channel A)   |
+| `SPI0_SDO_PIN`    | `GPIO19`     |                   | `I2C1` (SCL)         | `PWM1` (channel B)   |
+| `SPI0_SDI_PIN`    | `GPIO20`     |                   | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `UART0_TX_PIN`    | `GPIO0`      | `UART_TX_PIN`     | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `UART0_RX_PIN`    | `GPIO1`      | `UART_RX_PIN`     | `I2C0` (SCL)         | `PWM0` (channel B)   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Adafruit Feather RP2040](../machine/feather-rp2040)
+
+## Flashing
+
+### UF2
+
+The Feather RP2040 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=feather-rp2040 [PATH TO YOUR PROGRAM]
+    ```
+
+- The Feather RP2040 board should restart and then begin running your program.
+
+### Troubleshooting
+
+Any troubleshooting tips go here.
+
+## Notes
+
+You can use the USB port to the Feather RP2040 as a serial port.
+
+TinyGo has support for the RP2040's on-board Programmable Input/Output (PIO) block.
+
+For more informantion, see [https://github.com/tinygo-org/pio](https://github.com/tinygo-org/pio)
diff --git a/content/docs/reference/microcontrollers/feather-stm32f405.md b/content/docs/reference/microcontrollers/feather-stm32f405.md
new file mode 100644
index 00000000..d63dd726
--- /dev/null
+++ b/content/docs/reference/microcontrollers/feather-stm32f405.md
@@ -0,0 +1,102 @@
+---
+title: "Adafruit Feather STM32F405 Express"
+weight: 3
+---
+
+The [Adafruit Feather STM32F405](https://www.adafruit.com/product/4382) is a tiny ARM development board based on the ST Micro [STM32F405](https://www.st.com/resource/en/datasheet/dm00037051.pdf) family of microcontrollers.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | Not yet |
+| USBDevice | YES | Not yet |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `D0`              | `PB11`       | `UART1_RX_PIN`, `UART0_RX_PIN`, `UART_RX_PIN`, `I2C2_SDA_PIN` |
+| `D1`              | `PB10`       | `UART1_TX_PIN`, `UART0_TX_PIN`, `UART_TX_PIN`, `I2C2_SCL_PIN` |
+| `D2`              | `PB3`        | `SPI2_SCK_PIN`    |
+| `D3`              | `PB4`        | `SPI2_SDI_PIN`    |
+| `D4`              | `PB5`        | `SPI2_SDO_PIN`    |
+| `D5`              | `PC7`        | `UART2_RX_PIN`    |
+| `D6`              | `PC6`        | `UART2_TX_PIN`    |
+| `D7`              | `PA15`       |                   |
+| `D8`              | `PC0`        | `LED_NEOPIXEL`, `WS2812` |
+| `D9`              | `PB8`        | `I2C3_SDA_PIN`    |
+| `D10`             | `PB9`        | `I2C3_SCL_PIN`    |
+| `D11`             | `PC3`        |                   |
+| `D12`             | `PC2`        |                   |
+| `D13`             | `PC1`        | `LED_RED`, `LED_BUILTIN`, `LED` |
+| `D14`             | `PB7`        | `UART3_RX_PIN`, `I2C1_SDA_PIN`, `I2C0_SDA_PIN`, `I2C_SDA_PIN`, `SDA_PIN` |
+| `D15`             | `PB6`        | `UART3_TX_PIN`, `I2C1_SCL_PIN`, `I2C0_SCL_PIN`, `I2C_SCL_PIN`, `SCL_PIN` |
+| `D16`             | `PA4`        | `A0`              |
+| `D17`             | `PA5`        | `A1`, `SPI3_SCK_PIN` |
+| `D18`             | `PA6`        | `A2`, `SPI3_SDI_PIN` |
+| `D19`             | `PA7`        | `A3`, `SPI3_SDO_PIN` |
+| `D20`             | `PC4`        | `A4`              |
+| `D21`             | `PC5`        | `A5`              |
+| `D22`             | `PA3`        | `A6`              |
+| `D23`             | `PB13`       | `SPI1_SCK_PIN`, `SPI0_SCK_PIN`, `SPI_SCK_PIN` |
+| `D24`             | `PB14`       | `SPI1_SDI_PIN`, `SPI0_SDI_PIN`, `SPI_SDI_PIN` |
+| `D25`             | `PB15`       | `SPI1_SDO_PIN`, `SPI0_SDO_PIN`, `SPI_SDO_PIN` |
+| `D26`             | `PC8`        |                   |
+| `D27`             | `PC9`        |                   |
+| `D28`             | `PC10`       |                   |
+| `D29`             | `PC11`       |                   |
+| `D30`             | `PC12`       |                   |
+| `D31`             | `PD2`        |                   |
+| `D32`             | `PB12`       |                   |
+| `D33`             | `PC14`       |                   |
+| `D34`             | `PC15`       |                   |
+| `D35`             | `PA11`       |                   |
+| `D36`             | `PA12`       |                   |
+| `D37`             | `PA13`       |                   |
+| `D38`             | `PA14`       |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Adafruit Feather STM32F405](../machine/feather-stm32f405)
+
+## Flashing
+
+Flashing this board using its DFU bootloader can be a bit cumbersome, but it is possible - without requiring an external programmer - by pulling the B0 pin high (you can use the board's 3.3V output pin) at bootup when connected to host PC via USB. This puts the device in bootloader mode.
+For more information see [Adafruit docs](https://learn.adafruit.com/adafruit-stm32f405-feather-express/dfu-bootloader-details).
+
+Once in bootloader mode, the device can be programmed using the open-source tool `dfu-util`.
+
+### CLI Flashing on Linux
+
+You must first install the `dfu-util` program in order to flash the Adafruit Feather STM32F405 board.
+
+    sudo apt update 
+    sudo apt install dfu-util
+
+### CLI Flashing on macOS
+
+You must first install the `dfu-util` program in order to flash the Adafruit Feather STM32F405 board. You can do this using Homebrew on macOS:
+
+    brew install dfu-util
+
+### CLI Flashing on Windows
+
+You must first install the `dfu-util` program in order to flash the Adafruit Feather STM32F405 board.
+
+- Download dfu-util from the website here: http://dfu-util.sourceforge.net/releases/dfu-util-0.9-win64.zip
+- Decompress the files to a directory such as `C:\dfu-util`
+- Add `C:\dfu-util` to your `PATH`.
+
+### Troubleshooting
+
+If you run into trouble getting dfu-util installed and working on Windows, see the blog post at https://www.hanselman.com/blog/HowToFixDfuutilSTMWinUSBZadigBootloadersAndOtherFirmwareFlashingIssuesOnWindows.aspx
+
+## Notes
+
+Goes here
diff --git a/content/docs/reference/microcontrollers/gameboy-advance.md b/content/docs/reference/microcontrollers/gameboy-advance.md
new file mode 100644
index 00000000..36fef9e1
--- /dev/null
+++ b/content/docs/reference/microcontrollers/gameboy-advance.md
@@ -0,0 +1,55 @@
+---
+title: "Game Boy Advance"
+weight: 3
+---
+
+The [Game Boy Advance](https://en.wikipedia.org/wiki/Game_Boy_Advance) is a handheld videogame platform based on the [ARM7TDMI](http://infocenter.arm.com/help/topic/com.arm.doc.ddi0210c/DDI0210B.pdf) microcontroller.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | ?   | ?   |
+| UART      | ?   | ?   |
+| SPI       | ?   | ?   |
+| I2C       | ?   | ?   |
+| ADC       | ?   | ?   |
+| PWM       | ?   | ?   |
+| USBDevice | ?   | ?   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Gameboy Advance](../machine/gameboy-advance)
+
+## Installing dependencies
+
+You can use a Game Boy Advance software emulator such as MGBA (https://mgba.io) to test your programs.
+
+
+## Building code
+
+Build your Game Boy Advance programs using `-target gameboy-advance` like this:
+
+```shell
+tinygo build -o main.gba -target gameboy-advance examples/gba-display
+```
+
+You can now use the GBA file with your emulator or flash it onto your physical hardware.
+
+## Examples
+
+* [gba-display](https://github.com/tinygo-org/tinygo/blob/release/src/examples/gba-display/gba-display.go)
+* [Other GBA examples (Buttons, Gopher, Snake...)](https://github.com/tinygo-org/tinygba/tree/main/examples)
+
+## Flashing
+
+Programs will need to be flashed onto a GBA reproduction cartridge.
+You can purchase reproduction cartridges from a site like [inside gadgets](https://shop.insidegadgets.com/?post_type=product&filter_flash-carts=gba), though there are other retailers that carry them as well.
+
+There are a couple pieces of hardware that can be used to flash your games onto a reproduction cartridge.
+* [GBxCart RW](https://www.gbxcart.com/)
+* [Joey Jr](https://bennvenn.myshopify.com/collections/game-cart-to-pc-interface/products/usb-gb-c-cart-dumper-the-joey-jr)
+
+Both of these tools use [FlashGBX](https://github.com/lesserkuma/FlashGBX/tree/4.2) for flashing cartridges.
+Once you have installed FlashGBX, insert a reproduction cart into your hardware flasher of choice and plug it into your computer.
+FlashGBX has a GUI you can then use to write your program onto the cart.
diff --git a/content/docs/reference/microcontrollers/grandcentral-m4.md b/content/docs/reference/microcontrollers/grandcentral-m4.md
new file mode 100644
index 00000000..6b06c02d
--- /dev/null
+++ b/content/docs/reference/microcontrollers/grandcentral-m4.md
@@ -0,0 +1,155 @@
+---
+title: "Adafruit Grand Central M4"
+weight: 3
+---
+
+The [Adafruit Grand Central M4](https://www.adafruit.com/product/4064) is a tiny ARM development board based on the Atmel [ATSAMD51P20](https://www.microchip.com/wwwproducts/en/ATSAMD51P20A) family of SoC.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `D0`              | `PB25`       | `UART1_RX_PIN`, `UART_RX_PIN` |                      |                      |
+| `D1`              | `PB24`       | `UART1_TX_PIN`, `UART_TX_PIN` |                      |                      |
+| `D2`              | `PC18`       |                   |                      | `TCC0` (channel 2)   |
+| `D3`              | `PC19`       |                   |                      | `TCC0` (channel 3)   |
+| `D4`              | `PC20`       |                   |                      | `TCC0` (channel 4)   |
+| `D5`              | `PC21`       |                   |                      | `TCC0` (channel 5)   |
+| `D6`              | `PD20`       |                   |                      | `TCC1` (channel 0)   |
+| `D7`              | `PD21`       |                   |                      | `TCC1` (channel 1)   |
+| `D8`              | `PB18`       |                   |                      | `TCC1` (channel 0)   |
+| `D9`              | `PB02`       |                   |                      | `TCC2` (channel 2)   |
+| `D10`             | `PB22`       |                   |                      |                      |
+| `D11`             | `PB23`       |                   |                      |                      |
+| `D12`             | `PB00`       |                   |                      |                      |
+| `D13`             | `PB01`       | `D87`, `LED_PIN`, `LED` |                      |                      |
+| `D14`             | `PB16`       | `UART4_TX_PIN`, `I2S0_SCK_PIN`, `I2S_SCK_PIN` |                      | `TCC3` (channel 0), `TCC0` (channel 4) |
+| `D15`             | `PB17`       | `UART4_RX_PIN`, `I2S0_MCK_PIN` |                      | `TCC3` (channel 1), `TCC0` (channel 5) |
+| `D16`             | `PC22`       | `UART3_TX_PIN`    |                      | `TCC0` (channel 6)   |
+| `D17`             | `PC23`       | `UART3_RX_PIN`    |                      | `TCC0` (channel 7)   |
+| `D18`             | `PB12`       | `UART2_TX_PIN`    |                      | `TCC3` (channel 0), `TCC0` (channel 0) |
+| `D19`             | `PB13`       | `UART2_RX_PIN`    |                      | `TCC3` (channel 1), `TCC0` (channel 1) |
+| `D20`             | `PB20`       | `D62`, `I2C0_SDA_PIN`, `I2C_SDA_PIN`, `SDA_PIN` |                      | `TCC1` (channel 2)   |
+| `D21`             | `PB21`       | `D63`, `I2C0_SCL_PIN`, `I2C_SCL_PIN`, `SCL_PIN` |                      | `TCC1` (channel 3)   |
+| `D22`             | `PD12`       |                   |                      | `TCC0` (channel 5)   |
+| `D23`             | `PA15`       |                   |                      | `TCC2` (channel 1), `TCC1` (channel 3) |
+| `D24`             | `PC17`       | `I2C1_SCL_PIN`    |                      | `TCC0` (channel 1)   |
+| `D25`             | `PC16`       | `I2C1_SDA_PIN`    |                      | `TCC0` (channel 0)   |
+| `D26`             | `PA12`       |                   |                      | `TCC0` (channel 6), `TCC1` (channel 2) |
+| `D27`             | `PA13`       |                   |                      | `TCC0` (channel 7), `TCC1` (channel 3) |
+| `D28`             | `PA14`       |                   |                      | `TCC2` (channel 0), `TCC1` (channel 2) |
+| `D29`             | `PB19`       |                   |                      | `TCC1` (channel 1)   |
+| `D30`             | `PA23`       |                   | `I2C0` (SCL)         | `TCC1` (channel 7), `TCC0` (channel 3) |
+| `D31`             | `PA22`       | `I2S0_SDI_PIN`    | `I2C0` (SDA)         | `TCC1` (channel 6), `TCC0` (channel 2) |
+| `D32`             | `PA21`       | `I2S0_SDO_PIN`, `I2S_SDO_PIN` |                      | `TCC1` (channel 5), `TCC0` (channel 1) |
+| `D33`             | `PA20`       | `I2S0_FS_PIN`, `I2S_WS_PIN` |                      | `TCC1` (channel 4), `TCC0` (channel 0) |
+| `D34`             | `PA19`       |                   |                      | `TCC1` (channel 3), `TCC0` (channel 7) |
+| `D35`             | `PA18`       |                   |                      | `TCC1` (channel 2), `TCC0` (channel 6) |
+| `D36`             | `PA17`       |                   | `I2C0` (SCL)         | `TCC1` (channel 1), `TCC0` (channel 5) |
+| `D37`             | `PA16`       |                   | `I2C0` (SDA)         | `TCC1` (channel 0), `TCC0` (channel 4) |
+| `D38`             | `PB15`       |                   |                      | `TCC4` (channel 1), `TCC0` (channel 3) |
+| `D39`             | `PB14`       |                   |                      | `TCC4` (channel 0), `TCC0` (channel 2) |
+| `D40`             | `PC13`       |                   |                      | `TCC0` (channel 3), `TCC1` (channel 7) |
+| `D41`             | `PC12`       |                   |                      | `TCC0` (channel 2), `TCC1` (channel 6) |
+| `D42`             | `PC15`       |                   |                      | `TCC0` (channel 5), `TCC1` (channel 1) |
+| `D43`             | `PC14`       |                   |                      | `TCC0` (channel 4), `TCC1` (channel 0) |
+| `D44`             | `PC11`       |                   |                      | `TCC0` (channel 1), `TCC1` (channel 5) |
+| `D45`             | `PC10`       |                   |                      | `TCC0` (channel 0), `TCC1` (channel 4) |
+| `D46`             | `PC06`       |                   |                      |                      |
+| `D47`             | `PC07`       |                   |                      |                      |
+| `D48`             | `PC04`       |                   |                      | `TCC0` (channel 0)   |
+| `D49`             | `PC05`       |                   |                      | `TCC0` (channel 1)   |
+| `D50`             | `PD11`       | `D64`, `SPI0_SDI_PIN`, `SPI_SDI_PIN` |                      | `TCC0` (channel 4)   |
+| `D51`             | `PD08`       | `D65`, `SPI0_SDO_PIN`, `SPI_SDO_PIN` | `I2C1` (SDA)         | `TCC0` (channel 1)   |
+| `D52`             | `PD09`       | `D66`, `SPI0_SCK_PIN`, `SPI_SCK_PIN` | `I2C1` (SCL)         | `TCC0` (channel 2)   |
+| `D53`             | `PD10`       | `SPI0_CS_PIN`, `SPI_CS_PIN` |                      | `TCC0` (channel 3)   |
+| `D54`             | `PB05`       | `A8`              |                      |                      |
+| `D55`             | `PB06`       | `A9`              |                      |                      |
+| `D56`             | `PB07`       | `A10`             |                      |                      |
+| `D57`             | `PB08`       | `A11`             |                      |                      |
+| `D58`             | `PB09`       | `A12`             |                      |                      |
+| `D59`             | `PA04`       | `A13`             |                      |                      |
+| `D60`             | `PA06`       | `A14`             |                      |                      |
+| `D61`             | `PA07`       | `A15`             |                      |                      |
+| `D67`             | `PA02`       | `D85`, `A0`       |                      |                      |
+| `D68`             | `PA05`       | `D86`, `A1`       |                      |                      |
+| `D69`             | `PB03`       | `A2`              |                      | `TCC2` (channel 3)   |
+| `D70`             | `PC00`       | `A3`              |                      |                      |
+| `D71`             | `PC01`       | `A4`              |                      |                      |
+| `D72`             | `PC02`       | `A5`              |                      |                      |
+| `D73`             | `PC03`       | `A6`              |                      |                      |
+| `D74`             | `PB04`       | `A7`              |                      |                      |
+| `D75`             | `PC31`       | `UART_RX_LED_PIN`, `LED_RX` |                      |                      |
+| `D76`             | `PC30`       | `UART_TX_LED_PIN`, `LED_TX` |                      |                      |
+| `D77`             | `PA27`       | `USBCDC_HOSTEN_PIN` |                      |                      |
+| `D78`             | `PA24`       | `USBCDC_DM_PIN`   |                      | `TCC2` (channel 2)   |
+| `D79`             | `PA25`       | `USBCDC_DP_PIN`   |                      | `TCC2` (channel 3)   |
+| `D80`             | `PB29`       | `SPI1_SDI_PIN`, `SD0_SDI_PIN`, `SDCARD_SDI_PIN` |                      | `TCC1` (channel 5)   |
+| `D81`             | `PB27`       | `SPI1_SCK_PIN`, `SD0_SCK_PIN`, `SDCARD_SCK_PIN` |                      | `TCC1` (channel 3)   |
+| `D82`             | `PB26`       | `SPI1_SDO_PIN`, `SD0_SDO_PIN`, `SDCARD_SDO_PIN` |                      | `TCC1` (channel 2)   |
+| `D83`             | `PB28`       | `SD0_CS_PIN`, `SDCARD_CS_PIN` |                      | `TCC1` (channel 4)   |
+| `D84`             | `PA03`       | `AREF`            |                      |                      |
+| `D88`             | `PC24`       | `NEOPIXEL_PIN`, `NEOPIXEL`, `WS2812` |                      |                      |
+| `D89`             | `PB10`       | `QSPI_SCK`        |                      | `TCC0` (channel 4), `TCC1` (channel 0) |
+| `D90`             | `PB11`       | `QSPI_CS`         |                      | `TCC0` (channel 5), `TCC1` (channel 1) |
+| `D91`             | `PA08`       | `QSPI_DATA0`      |                      | `TCC0` (channel 0), `TCC1` (channel 4) |
+| `D92`             | `PA09`       | `QSPI_DATA1`      |                      | `TCC0` (channel 1), `TCC1` (channel 5) |
+| `D93`             | `PA10`       | `QSPI_DATA2`      |                      | `TCC0` (channel 2), `TCC1` (channel 6) |
+| `D94`             | `PA11`       | `QSPI_DATA3`      |                      | `TCC0` (channel 3), `TCC1` (channel 7) |
+| `D95`             | `PB31`       | `SD0_DET_PIN`, `SDCARD_DET_PIN` |                      | `TCC4` (channel 1), `TCC0` (channel 7) |
+| `D96`             | `PB30`       |                   |                      | `TCC4` (channel 0), `TCC0` (channel 6) |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Adafruit Grand Central M4](../machine/grandcentral-m4)
+
+## Flashing
+
+### UF2
+
+The Grand Central M4 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Plug your Grand Central M4 into your computer's USB port.
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=grandcentral-m4 [PATH TO YOUR PROGRAM]
+    ```
+
+- The Grand Central M4 board should restart and then begin running your program.
+
+
+### Troubleshooting
+
+If you have troubles getting your Grand Central M4 board to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the Grand Central M4 board ready to receive code.
+- The Grand Central M4 board will appear to your computer like a USB drive.
+- Now try running the command as above:
+
+
+```shell
+tinygo flash -target=grandcentral-m4 [PATH TO YOUR PROGRAM]
+```
+
+Once you have updated your Grand Central M4 board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You can use the USB port to the Grand Central M4 as a serial port. `UART0` refers to this connection.
+
+The Neopixel LED on the Grand Central M4 can be accessed using the [WS2812](https://pkg.go.dev/tinygo.org/x/drivers/ws2812) driver via the `PC24` pin
diff --git a/content/docs/reference/microcontrollers/hifive1b.md b/content/docs/reference/microcontrollers/hifive1b.md
new file mode 100644
index 00000000..f87a3e5e
--- /dev/null
+++ b/content/docs/reference/microcontrollers/hifive1b.md
@@ -0,0 +1,62 @@
+---
+title: "SiFive HiFive1 Rev B"
+weight: 3
+---
+
+The [HiFive1 Rev B](https://www.sifive.com/boards/hifive1-rev-b) is low-cost, Arduino-compatible development board featuring the [Freedom E310](https://www.sifive.com/chip-designer#fe310) 320+ MHz [RISC-V](https://riscv.org/) chip.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | NO  | NO  |
+| PWM       | YES | Not yet |
+| USBDevice | ?   | ?   |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  |
+| ----------------- | ------------ | ----------------- | -------------------- |
+| `D0`              | `P16`        | `D7`, `UART_RX_PIN` |                      |
+| `D1`              | `P17`        | `UART_TX_PIN`     |                      |
+| `D2`              | `P18`        |                   |                      |
+| `D3`              | `P19`        | `LED2`, `LED_GREEN` |                      |
+| `D4`              | `P20`        |                   |                      |
+| `D5`              | `P21`        | `LED3`, `LED_BLUE` |                      |
+| `D6`              | `P22`        | `LED`, `LED1`, `LED_RED` |                      |
+| `D9`              | `P01`        |                   |                      |
+| `D10`             | `P02`        |                   |                      |
+| `D11`             | `P03`        | `SPI1_SDO_PIN`    |                      |
+| `D12`             | `P04`        | `SPI1_SDI_PIN`    |                      |
+| `D13`             | `P05`        | `SPI1_SCK_PIN`    |                      |
+| `D15`             | `P09`        |                   |                      |
+| `D16`             | `P10`        |                   |                      |
+| `D17`             | `P11`        |                   |                      |
+| `D18`             | `P12`        | `I2C0_SDA_PIN`    | `I2C0` (SDA)         |
+| `D19`             | `P13`        | `I2C0_SCL_PIN`    | `I2C0` (SCL)         |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the SiFive HiFive1b](../machine/hifive1b)
+
+## Flashing
+
+### MSD Flashing
+
+The HiFive1 RevB comes with a bootloader that allows Mass Storage Device (MSD) flashing. This means you can just copy the compiled `.hex` file generated by TinyGo onto it, no additional flashing software is needed.
+
+- Plug your HiFive1 RevB into your computer's USB port.
+
+- The HiFive1 RevB board will appear to your computer like a USB drive.
+
+- Build and flash your TinyGo program using `tinygo flash` like this:
+
+    ```shell
+    tinygo flash -target=hifive1b [PATH TO YOUR PROGRAM]
+    ```
+
+- The HiFive1 RevB should restart and begin running your program.
diff --git a/content/docs/reference/microcontrollers/itsybitsy-m0.md b/content/docs/reference/microcontrollers/itsybitsy-m0.md
new file mode 100644
index 00000000..8356f507
--- /dev/null
+++ b/content/docs/reference/microcontrollers/itsybitsy-m0.md
@@ -0,0 +1,95 @@
+---
+title: "Adafruit ItsyBitsy M0"
+weight: 3
+---
+
+The [Adafruit ItsyBitsy M0](https://www.adafruit.com/product/3727) is very compact ARM development board based on the Atmel [SAMD21](https://www.microchip.com/wwwproducts/en/ATSAMD21G18) family of SoC.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `D0`              | `PA11`       |                   |                      | `TCC1` (channel 1), `TCC0` (channel 3) |
+| `D1`              | `PA10`       | `I2S_SCK_PIN`     |                      | `TCC1` (channel 0), `TCC0` (channel 2) |
+| `D2`              | `PA14`       |                   |                      | `TCC0` (channel 0)   |
+| `D3`              | `PA09`       |                   |                      | `TCC0` (channel 1), `TCC1` (channel 3) |
+| `D4`              | `PA08`       | `I2S_SDO_PIN`     |                      | `TCC0` (channel 0), `TCC1` (channel 2) |
+| `D5`              | `PA15`       |                   |                      | `TCC0` (channel 1)   |
+| `D6`              | `PA20`       |                   |                      | `TCC0` (channel 2)   |
+| `D7`              | `PA21`       |                   |                      | `TCC0` (channel 3)   |
+| `D8`              | `PA06`       |                   |                      | `TCC1` (channel 0)   |
+| `D9`              | `PA07`       |                   |                      | `TCC1` (channel 1)   |
+| `D10`             | `PA18`       | `UART_TX_PIN`     |                      | `TCC0` (channel 2)   |
+| `D11`             | `PA16`       | `UART_RX_PIN`     | `I2C0` (SDA)         | `TCC2` (channel 0), `TCC0` (channel 2) |
+| `D12`             | `PA19`       |                   |                      | `TCC0` (channel 3)   |
+| `D13`             | `PA17`       | `LED`             | `I2C0` (SCL)         | `TCC2` (channel 1), `TCC0` (channel 3) |
+| `A0`              | `PA02`       |                   |                      |                      |
+| `A1`              | `PB08`       |                   |                      |                      |
+| `A2`              | `PB09`       |                   |                      |                      |
+| `A3`              | `PA04`       |                   |                      | `TCC0` (channel 0)   |
+| `A4`              | `PA05`       |                   |                      | `TCC0` (channel 1)   |
+| `A5`              | `PB02`       |                   |                      |                      |
+| `USBCDC_DM_PIN`   | `PA24`       |                   |                      | `TCC1` (channel 2)   |
+| `USBCDC_DP_PIN`   | `PA25`       |                   |                      | `TCC1` (channel 3)   |
+| `SDA_PIN`         | `PA22`       |                   | `I2C0` (SDA)         | `TCC0` (channel 0)   |
+| `SCL_PIN`         | `PA23`       |                   | `I2C0` (SCL)         | `TCC0` (channel 1)   |
+| `SPI0_SCK_PIN`    | `PB11`       |                   |                      | `TCC0` (channel 1)   |
+| `SPI0_SDO_PIN`    | `PB10`       |                   |                      | `TCC0` (channel 0)   |
+| `SPI0_SDI_PIN`    | `PA12`       |                   |                      | `TCC2` (channel 0), `TCC0` (channel 2) |
+| `SPI1_CS_PIN`     | `PA27`       |                   |                      |                      |
+| `SPI1_SCK_PIN`    | `PB23`       |                   |                      |                      |
+| `SPI1_SDO_PIN`    | `PB22`       |                   |                      |                      |
+| `SPI1_SDI_PIN`    | `PB03`       |                   |                      |                      |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Adafruit ItsyBitsy M0](../machine/itsybitsy-m0)
+
+## Flashing
+
+### UF2
+
+The ItsyBitsy M0 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Plug your ItsyBitsy M0 into your computer's USB port.
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=itsybitsy-m0 [PATH TO YOUR PROGRAM]
+    ```
+
+- The ItsyBitsy M0 board should restart and then begin running your program.
+
+### Troubleshooting
+
+If you have troubles getting your ItsyBitsy M0 board to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the ItsyBitsy M0 board ready to receive code.
+- The ItsyBitsy M0 board will appear to your computer like a USB drive.
+- Now try running the command:
+
+    ```shell
+    tinygo flash -target=itsybitsy-m0 [PATH TO YOUR PROGRAM]
+    ```
+
+Once you have updated your ItsyBitsy M0 board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You can use the USB port to the ItsyBitsy M0 as a serial port. `UART0` refers to this connection.
+
+The DotStar LED on the ItsyBitsy M0 can be accessed using the [APA102](https://pkg.go.dev/tinygo.org/x/drivers/apa102) driver via a software SPI on the `PA00` and `PA01` pins
diff --git a/content/docs/reference/microcontrollers/itsybitsy-m4.md b/content/docs/reference/microcontrollers/itsybitsy-m4.md
new file mode 100644
index 00000000..5ef55faf
--- /dev/null
+++ b/content/docs/reference/microcontrollers/itsybitsy-m4.md
@@ -0,0 +1,97 @@
+---
+title: "Adafruit ItsyBitsy M4"
+weight: 3
+---
+
+The [Adafruit ItsyBitsy M4](https://www.adafruit.com/product/3800) is very compact ARM development board based on the Atmel [SAMD51](https://www.microchip.com/wwwproducts/en/ATSAMD51G19A) family of SoC.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `D0`              | `PA16`       | `UART_RX_PIN`     |                      | `TCC1` (channel 0), `TCC0` (channel 4) |
+| `D1`              | `PA17`       | `UART_TX_PIN`     |                      | `TCC1` (channel 1), `TCC0` (channel 5) |
+| `D2`              | `PA07`       | `UART2_RX_PIN`    |                      |                      |
+| `D3`              | `PB22`       |                   |                      |                      |
+| `D4`              | `PA14`       |                   |                      | `TCC2` (channel 0), `TCC1` (channel 2) |
+| `D5`              | `PA15`       |                   |                      | `TCC2` (channel 1), `TCC1` (channel 3) |
+| `D6`              | `PB02`       |                   |                      | `TCC2` (channel 2)   |
+| `D7`              | `PA18`       |                   |                      | `TCC1` (channel 2), `TCC0` (channel 6) |
+| `D8`              | `PB03`       |                   |                      | `TCC2` (channel 3)   |
+| `D9`              | `PA19`       |                   |                      | `TCC1` (channel 3), `TCC0` (channel 7) |
+| `D10`             | `PA20`       |                   |                      | `TCC1` (channel 4), `TCC0` (channel 0) |
+| `D11`             | `PA21`       |                   |                      | `TCC1` (channel 5), `TCC0` (channel 1) |
+| `D12`             | `PA23`       |                   |                      | `TCC1` (channel 7), `TCC0` (channel 3) |
+| `D13`             | `PA22`       | `LED`             |                      | `TCC1` (channel 6), `TCC0` (channel 2) |
+| `A0`              | `PA02`       |                   |                      |                      |
+| `A1`              | `PA05`       |                   |                      |                      |
+| `A2`              | `PB08`       |                   |                      |                      |
+| `A3`              | `PB09`       |                   |                      |                      |
+| `A4`              | `PA04`       | `UART2_TX_PIN`    |                      |                      |
+| `A5`              | `PA06`       |                   |                      |                      |
+| `USBCDC_DM_PIN`   | `PA24`       |                   |                      | `TCC2` (channel 2)   |
+| `USBCDC_DP_PIN`   | `PA25`       |                   |                      | `TCC2` (channel 3)   |
+| `SDA_PIN`         | `PA12`       |                   | `I2C0` (SDA)         | `TCC0` (channel 6), `TCC1` (channel 2) |
+| `SCL_PIN`         | `PA13`       |                   | `I2C0` (SCL)         | `TCC0` (channel 7), `TCC1` (channel 3) |
+| `SPI0_SCK_PIN`    | `PA01`       |                   |                      |                      |
+| `SPI0_SDO_PIN`    | `PA00`       |                   |                      |                      |
+| `SPI0_SDI_PIN`    | `PB23`       |                   |                      |                      |
+| `QSPI_SCK`        | `PB10`       |                   |                      | `TCC0` (channel 4), `TCC1` (channel 0) |
+| `QSPI_CS`         | `PB11`       |                   |                      | `TCC0` (channel 5), `TCC1` (channel 1) |
+| `QSPI_DATA0`      | `PA08`       |                   | `I2C0` (SDA)         | `TCC0` (channel 0), `TCC1` (channel 4) |
+| `QSPI_DATA1`      | `PA09`       |                   | `I2C0` (SCL)         | `TCC0` (channel 1), `TCC1` (channel 5) |
+| `QSPI_DATA2`      | `PA10`       |                   |                      | `TCC0` (channel 2), `TCC1` (channel 6) |
+| `QSPI_DATA3`      | `PA11`       |                   |                      | `TCC0` (channel 3), `TCC1` (channel 7) |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Adafruit ItsyBitsy M4](../machine/itsybitsy-m4)
+
+## Flashing
+
+### UF2
+
+The ItsyBitsy M4 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Plug your ItsyBitsy M4 into your computer's USB port.
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=itsybitsy-m4 [PATH TO YOUR PROGRAM]
+    ```
+
+- The ItsyBitsy M4 board should restart and then begin running your program.
+
+### Troubleshooting
+
+If you have troubles getting your ItsyBitsy M4 board to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the ItsyBitsy M4 board ready to receive code.
+- The ItsyBitsy M4 board will appear to your computer like a USB drive.
+- Now try running the command as above:
+
+    ```shell
+    tinygo flash -target=itsybitsy-m4 [PATH TO YOUR PROGRAM]
+    ```
+
+Once you have updated your ItsyBitsy M4 board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You can use the USB port to the ItsyBitsy M4 as a serial port. `UART0` refers to this connection.
+
+The DotStar LED on the ItsyBitsy M4 can be accessed using the [APA102](https://pkg.go.dev/tinygo.org/x/drivers/apa102) driver via a software SPI on the `PB02` and `PB03` pins
diff --git a/content/docs/reference/microcontrollers/itsybitsy-nrf52840.md b/content/docs/reference/microcontrollers/itsybitsy-nrf52840.md
new file mode 100644
index 00000000..4e1cd094
--- /dev/null
+++ b/content/docs/reference/microcontrollers/itsybitsy-nrf52840.md
@@ -0,0 +1,139 @@
+---
+title: "Adafruit ItsyBitsy nRF52840"
+weight: 3
+---
+
+The [Adafruit ItsyBitsy-nRF52840](https://www.adafruit.com/product/4333) is a small ARM development board based on the Nordic Semiconductor [nrf52840](https://www.nordicsemi.com/eng/Products/nRF52840)  processor.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+| Bluetooth | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `D0`              | `P0_25`      | `UART_RX_PIN`     |
+| `D1`              | `P0_24`      | `UART_TX_PIN`     |
+| `D2`              | `P1_02`      |                   |
+| `D3`              | `P0_06`      | `LED`, `LED1`     |
+| `D4`              | `P0_29`      | `BUTTON`          |
+| `D5`              | `P0_27`      |                   |
+| `D6`              | `P1_09`      |                   |
+| `D7`              | `P1_08`      |                   |
+| `D8`              | `P0_08`      |                   |
+| `D9`              | `P0_07`      |                   |
+| `D10`             | `P0_05`      | `D20`, `A6`       |
+| `D11`             | `P0_26`      |                   |
+| `D12`             | `P0_11`      |                   |
+| `D13`             | `P0_12`      |                   |
+| `D14`             | `P0_04`      | `A0`              |
+| `D15`             | `P0_30`      | `A1`              |
+| `D16`             | `P0_28`      | `A2`              |
+| `D17`             | `P0_31`      | `A3`              |
+| `D18`             | `P0_02`      | `A4`              |
+| `D19`             | `P0_03`      | `A5`              |
+| `D21`             | `P0_16`      | `SDA_PIN`         |
+| `D22`             | `P0_14`      | `SCL_PIN`         |
+| `D23`             | `P0_20`      | `SPI0_SDI_PIN`    |
+| `D24`             | `P0_15`      | `SPI0_SDO_PIN`    |
+| `D25`             | `P0_13`      | `SPI0_SCK_PIN`    |
+| `D26`             | `P0_19`      | `QSPI_SCK`        |
+| `D27`             | `P0_23`      | `QSPI_CS`         |
+| `D28`             | `P0_21`      | `QSPI_DATA0`      |
+| `D29`             | `P0_22`      | `QSPI_DATA1`      |
+| `D30`             | `P1_00`      | `QSPI_DATA2`      |
+| `D31`             | `P0_17`      | `QSPI_DATA3`      |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the ItsyBitsy-nRF52840](../machine/itsybitsy-nrf52840)
+
+## Flashing
+
+### UF2
+
+The ItsyBitsy-nRF52840 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+**PLEASE NOTE** that for a good experience using TinyGo on your board you must be running version 0.4.1 or above of the UF2 bootloader on the board. For more information, [see below](#updating-the-uf2-bootloader)
+
+### CLI Flashing
+
+- Plug your ItsyBitsy-nRF52840 into your computer's USB port.
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=itsybitsy-nrf52840 [PATH TO YOUR PROGRAM]
+    ```
+
+- The ItsyBitsy-nRF52840 board should restart and then begin running your program.
+
+### Troubleshooting
+
+If you have troubles getting your ItsyBitsy-nRF52840 board to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the ItsyBitsy-nRF52840 board ready to receive code.
+- The ItsyBitsy-nRF52840 board will appear to your computer like a USB drive.
+- Now try running the command:
+
+    ```shell
+    tinygo flash -target=itsybitsy-nrf52840 [PATH TO YOUR PROGRAM]
+    ```
+
+Once you have updated your ItsyBitsy-nRF52840 board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You can use the USB port to the ItsyBitsy-nRF52840 as a serial port. `UART0` refers to this connection.
+
+For an example that uses the built-in Neopixel LEDs, take a look at the TinyGo drivers repository located at [https://github.com/tinygo-org/drivers/tree/release/examples](https://github.com/tinygo-org/drivers)
+
+Bluetooth support is now available for the ItsyBitsy-nRF52840 board. See https://github.com/tinygo-org/bluetooth for more information.
+
+## Updating the UF2 bootloader
+
+This board uses a UF2 bootloader created by Adafruit: https://github.com/adafruit/Adafruit_nRF52_Bootloader
+
+We recommend bootloader version 0.4.1 or above. You can check what version is installed on your board by double-clicking the button on the board to launch the bootloader. When you do this, a USB volume that should automatically be mounted on your computer. Check the file named "INFO_UF2.TXT" on that drive. The bootloader firmware version should be listed in that file, for example:
+
+```
+UF2 Bootloader 0.4.1 lib/nrfx (v2.0.0) lib/tinyusb (0.6.0-272-g4e6aa0d8) lib/uf2 (remotes/origin/configupdate-9-gadbb8c7)
+Model: Adafruit ItsyBitsy nRF52840 Express
+Board-ID: nRF52840-ItsyBitsy-revA
+SoftDevice: S140 version 6.1.1
+Date: Jan 19 2021
+```
+
+To update the bootloader, you will need to install the `adafruit-nrfutil` program. 
+
+You can install it by running:
+
+```shell
+pip3 install --user adafruit-nrfutil
+```
+
+Once you have installed the `adafruit-nrfutil` program, download the firmware here: 
+https://github.com/adafruit/Adafruit_nRF52_Bootloader/releases/download/0.4.1/itsybitsy_nrf52840_express_bootloader-0.4.1.zip
+
+Unzip the files in this zip file and save them to a convenient location. 
+
+Plug in your board to your computer's USB port.
+
+Now we are ready to update the firmware. Run a command something like the following, adjusting for any difference based on where you have saved the files, and what your serial port is named:
+
+```shell
+ adafruit-nrfutil --verbose dfu serial --package itsybitsy_nrf52840_express_bootloader-0.4.1_s140_6.1.1.zip -p /dev/ttyACM0 -b 115200 --singlebank --touch 1200
+```
+
+Note that you should be flashing the board using the zip file that was contained within the zip file that you downloaded, NOT the file that you downloaded.
+
+Once you have flashed the board with the `adafruit-nrfutil` it should restart the board with the new bootloader. You only need to do this update once, and then from that point on the new bootloader will be active.
diff --git a/content/docs/reference/microcontrollers/lgt92.md b/content/docs/reference/microcontrollers/lgt92.md
new file mode 100644
index 00000000..16830813
--- /dev/null
+++ b/content/docs/reference/microcontrollers/lgt92.md
@@ -0,0 +1,57 @@
+---
+title: "Dragino LoRaWAN GPS Tracker LGT-92"
+weight: 3
+---
+
+The [Dragino LGT-92](https://www.dragino.com/products/lora-lorawan-end-node/item/142-lgt-92.html) includes a low power GPS module L76-L and 9-axis accelerometer for motion and attitude detection. It is based on the ST Micro [STM32L072CZT6](https://www.st.com/en/microcontrollers-microprocessors/stm32l072cz.html) SoC.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | Not yet |
+| USBDevice | YES | Not yet |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `LED1`            | `PA12`       | `LED_RED`, `LED`  |
+| `LED2`            | `PA8`        | `LED_BLUE`        |
+| `LED3`            | `PA11`       | `LED_GREEN`       |
+| `BUTTON`          | `PB14`       |                   |
+| `GPS_STANDBY_PIN` | `PB3`        |                   |
+| `GPS_RESET_PIN`   | `PB4`        |                   |
+| `GPS_POWER_PIN`   | `PB5`        |                   |
+| `MEMS_ACCEL_CS`   | `PE3`        |                   |
+| `MEMS_ACCEL_INT1` | `PE0`        |                   |
+| `MEMS_ACCEL_INT2` | `PE1`        |                   |
+| `SPI1_SCK_PIN`    | `PA5`        | `SPI0_SCK_PIN`    |
+| `SPI1_SDI_PIN`    | `PA6`        | `SPI0_SDI_PIN`    |
+| `SPI1_SDO_PIN`    | `PA7`        | `SPI0_SDO_PIN`    |
+| `RFM95_DIO0_PIN`  | `PC13`       |                   |
+| `UART_RX_PIN`     | `PA13`       |                   |
+| `UART_TX_PIN`     | `PA14`       |                   |
+| `UART1_RX_PIN`    | `PB6`        |                   |
+| `UART1_TX_PIN`    | `PB7`        |                   |
+| `I2C0_SCL_PIN`    | `PA9`        |                   |
+| `I2C0_SDA_PIN`    | `PA10`       |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Dragino LGT-92](../machine/lgt-92)
+
+## Flashing
+
+### OpenOCD
+
+Programs are loaded onto the Dragino LGT-92 with a separate hardware programmer such as the [STLink v2](https://www.st.com/en/development-tools/st-link-v2.html) board, using the `openocd` command line utility program to perform the board flashing. You must install [OpenOCD](http://openocd.org/) before you will be able to flash the Dragino LGT-92 board with your TinyGo code.
+
+- Plug your STLink v2 programmer into your computer's USB port.
+- Plug your Dragino LGT-92 into the STLink v2 programmer using the Dragino LGT-92 `SWIO`, `SWCLK`, `3V3` and `GND` pins.
+- Build and flash your TinyGo program using `tinygo flash -target=lgt92`
diff --git a/content/docs/reference/microcontrollers/lorae5.md b/content/docs/reference/microcontrollers/lorae5.md
new file mode 100644
index 00000000..4c5135eb
--- /dev/null
+++ b/content/docs/reference/microcontrollers/lorae5.md
@@ -0,0 +1,53 @@
+---
+title: "Seeed Studio LoRa-E5 Development Kit"
+weight: 3
+---
+
+The [LoRa-E5 Development Kit](https://www.seeedstudio.com/LoRa-E5-Dev-Kit-p-4868.html) is an ARM development board based on the ST Micro [STM32WLE5JC](https://www.st.com/en/microcontrollers-microprocessors/stm32wle5jc.html) SoC.
+
+It has onboard LoRa®, (G)FSK, (G)MSK, and BPSK as well as 1 user LED, 1 user buttons and 1 reset push-button
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | Not yet |
+| USBDevice | NO  | NO  |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `LED`             | `PB5`        |                   |
+| `POWER_EN3V3`     | `PA9`        |                   |
+| `POWER_EN5V`      | `PB10`       |                   |
+| `SPI0_NSS_PIN`    | `PA4`        |                   |
+| `SPI0_SCK_PIN`    | `PA5`        |                   |
+| `SPI0_SDO_PIN`    | `PA6`        |                   |
+| `SPI0_SDI_PIN`    | `PA7`        |                   |
+| `UART1_TX_PIN`    | `PB6`        | `UART_TX_PIN`     |
+| `UART1_RX_PIN`    | `PB7`        | `UART_RX_PIN`     |
+| `UART2_TX_PIN`    | `PA2`        |                   |
+| `UART2_RX_PIN`    | `PA3`        |                   |
+| `I2C2_SCL_PIN`    | `PB15`       | `I2C0_SCL_PIN`    |
+| `I2C2_SDA_PIN`    | `PA15`       | `I2C0_SDA_PIN`    |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the LoRa E5](../machine/lorae5)
+
+## Flashing
+
+### OpenOCD
+
+Programs are loaded onto the LoRa-E5 with an STLink hardware programmer, using the `openocd` command line utility program to perform the board flashing. You must install [OpenOCD](http://openocd.org/) before you will be able to flash the LoRa-E5 board with your TinyGo code.
+
+- Connect an ST-Link device to the SWD/SWIM headers.
+- Plug your LoRa-E5 board into your computer's USB port.
+- Plug your ST-Link device into your computer's USB port.
+- Build and flash your TinyGo program using `tinygo flash -target=lorae5`
diff --git a/content/docs/reference/microcontrollers/m5stack-core2.md b/content/docs/reference/microcontrollers/m5stack-core2.md
new file mode 100644
index 00000000..fadddba9
--- /dev/null
+++ b/content/docs/reference/microcontrollers/m5stack-core2.md
@@ -0,0 +1,161 @@
+---
+title: "M5Stack Core2"
+weight: 3
+---
+
+The [m5stack-core2](https://shop.m5stack.com/products/m5stack-core2-esp32-iot-development-kit) is a development board based on the Espressif ESP32 a powerful chip that is used on many different board mostly because of the built-in radio that can be used for WiFi or Bluetooth wireless connections.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | Not yet |
+| USBDevice | NO  | NO  |
+| WiFi      | YES | Not Yet |
+| Bluetooth | YES | Not yet |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `IO0`             | `GPIO0`      |                   |
+| `IO1`             | `GPIO1`      | `UART0_TX_PIN`, `UART_TX_PIN` |
+| `IO2`             | `GPIO2`      |                   |
+| `IO3`             | `GPIO3`      | `UART0_RX_PIN`, `UART_RX_PIN` |
+| `IO4`             | `GPIO4`      | `SDCARD_SS_PIN`   |
+| `IO5`             | `GPIO5`      | `SPI0_CS0_PIN`, `LCD_SS_PIN` |
+| `IO6`             | `GPIO6`      |                   |
+| `IO7`             | `GPIO7`      |                   |
+| `IO8`             | `GPIO8`      |                   |
+| `IO9`             | `GPIO9`      |                   |
+| `IO10`            | `GPIO10`     |                   |
+| `IO11`            | `GPIO11`     |                   |
+| `IO12`            | `GPIO12`     |                   |
+| `IO13`            | `GPIO13`     | `UART1_RX_PIN`    |
+| `IO14`            | `GPIO14`     | `UART1_TX_PIN`    |
+| `IO15`            | `GPIO15`     | `LCD_DC_PIN`      |
+| `IO16`            | `GPIO16`     |                   |
+| `IO17`            | `GPIO17`     |                   |
+| `IO18`            | `GPIO18`     | `SPI0_SCK_PIN`, `LCD_SCK_PIN`, `SDCARD_SCK_PIN` |
+| `IO19`            | `GPIO19`     |                   |
+| `IO21`            | `GPIO21`     | `SDA0_PIN`        |
+| `IO22`            | `GPIO22`     | `SCL0_PIN`        |
+| `IO23`            | `GPIO23`     | `SPI0_SDO_PIN`, `LCD_SDO_PIN`, `SDCARD_SDO_PIN` |
+| `IO25`            | `GPIO25`     | `DAC1`            |
+| `IO26`            | `GPIO26`     | `DAC2`            |
+| `IO27`            | `GPIO27`     |                   |
+| `IO32`            | `GPIO32`     | `SDA1_PIN`, `SDA_PIN` |
+| `IO33`            | `GPIO33`     | `SCL1_PIN`, `SCL_PIN` |
+| `IO34`            | `GPIO34`     |                   |
+| `IO35`            | `GPIO35`     | `ADC1`            |
+| `IO36`            | `GPIO36`     | `ADC2`            |
+| `IO38`            | `GPIO38`     | `SPI0_SDI_PIN`, `LCD_SDI_PIN`, `SDCARD_SDI_PIN` |
+| `IO39`            | `GPIO39`     |                   |
+
+## Pins
+
+| Pin              | Hardware pin | Alternative names |
+| ---------------- | ------------ | ----------------- |
+| `IO0`            | `GPIO0`      |                   |
+| `IO1`            | `GPIO1`      | `UART0_TX_PIN`, `UART_TX_PIN` |
+| `IO2`            | `GPIO2`      |                   |
+| `IO3`            | `GPIO3`      | `UART0_RX_PIN`, `UART_RX_PIN` |
+| `IO4`            | `GPIO4`      | `SDCARD_SS_PIN`   |
+| `IO5`            | `GPIO5`      | `SPI0_CS0_PIN`, `LCD_SS_PIN` |
+| `IO6`            | `GPIO6`      |                   |
+| `IO7`            | `GPIO7`      |                   |
+| `IO8`            | `GPIO8`      |                   |
+| `IO9`            | `GPIO9`      |                   |
+| `IO10`           | `GPIO10`     |                   |
+| `IO11`           | `GPIO11`     |                   |
+| `IO12`           | `GPIO12`     |                   |
+| `IO13`           | `GPIO13`     | `UART1_RX_PIN`    |
+| `IO14`           | `GPIO14`     | `UART1_TX_PIN`    |
+| `IO15`           | `GPIO15`     | `LCD_DC_PIN`      |
+| `IO16`           | `GPIO16`     |                   |
+| `IO17`           | `GPIO17`     |                   |
+| `IO18`           | `GPIO18`     | `SPI0_SCK_PIN`, `LCD_SCK_PIN`, `SDCARD_SCK_PIN` |
+| `IO19`           | `GPIO19`     |                   |
+| `IO21`           | `GPIO21`     | `SDA0_PIN`        |
+| `IO22`           | `GPIO22`     | `SCL0_PIN`        |
+| `IO23`           | `GPIO23`     | `SPI0_SDO_PIN`, `LCD_SDO_PIN`, `SDCARD_SDO_PIN` |
+| `IO25`           | `GPIO25`     | `DAC1`            |
+| `IO26`           | `GPIO26`     | `DAC2`            |
+| `IO27`           | `GPIO27`     |                   |
+| `IO32`           | `GPIO32`     | `SDA1_PIN`, `SDA_PIN` |
+| `IO33`           | `GPIO33`     | `SCL1_PIN`, `SCL_PIN` |
+| `IO34`           | `GPIO34`     |                   |
+| `IO35`           | `GPIO35`     | `ADC1`            |
+| `IO36`           | `GPIO36`     | `ADC2`            |
+| `IO38`           | `GPIO38`     | `SPI0_SDI_PIN`, `LCD_SDI_PIN`, `SDCARD_SDI_PIN` |
+| `IO39`           | `GPIO39`     |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the M5Stack Core2](../machine/m5stack-core2)
+
+## Flashing
+
+### CLI Flashing on Linux
+
+You need to install the `esptool` flashing tool:
+
+https://github.com/espressif/esptool#easy-installation
+
+Now you should be able to flash your board as follows:
+
+- Plug your ESP32 board into your computer's USB port.
+- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the ESP32 with the serial example:
+
+    ```
+    tinygo flash -target=m5stack-core2 -port=/dev/ttyUSB0 examples/serial
+    ```
+
+- The ESP32 board should restart and then begin running your program.
+
+### CLI Flashing on macOS
+
+You need to install the `esptool` flashing tool:
+
+https://github.com/espressif/esptool#easy-installation
+
+Now you should be able to flash your board as follows:
+
+- Plug your ESP32 board into your computer's USB port.
+- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the ESP32 with the serial example:
+
+    ```
+    tinygo flash -target=m5stack-core2 examples/serial
+    ```
+
+- The ESP32 board should restart and then begin running your program.
+
+### CLI Flashing on Windows
+
+You need to install the `esptool` flashing tool:
+
+https://github.com/espressif/esptool#easy-installation
+
+Now you should be able to flash your board as follows:
+
+- Plug your ESP32 board into your computer's USB port.
+- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the ESP32 with the serial example:
+
+    ```
+    tinygo flash -target=m5stack-core2 examples/serial
+    ```
+
+- The ESP32 board should restart and then begin running your program.
+
+### Troubleshooting
+
+Goes here
+
+## Notes
+
+Goes here
diff --git a/content/docs/reference/microcontrollers/m5stack.md b/content/docs/reference/microcontrollers/m5stack.md
new file mode 100644
index 00000000..f26fdb4a
--- /dev/null
+++ b/content/docs/reference/microcontrollers/m5stack.md
@@ -0,0 +1,124 @@
+---
+title: "M5Stack"
+weight: 3
+---
+
+The [m5stack](https://docs.m5stack.com/en/core/basic) is a development board based on the Espressif ESP32 a powerful chip that is used on many different board mostly because of the built-in radio that can be used for WiFi or Bluetooth wireless connections.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | Not yet |
+| USBDevice | NO  | NO  |
+| WiFi      | YES | Not Yet |
+| Bluetooth | YES | Not yet |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `IO0`             | `GPIO0`      |                   |
+| `IO1`             | `GPIO1`      | `UART0_TX_PIN`, `UART_TX_PIN` |
+| `IO2`             | `GPIO2`      |                   |
+| `IO3`             | `GPIO3`      | `UART0_RX_PIN`, `UART_RX_PIN` |
+| `IO4`             | `GPIO4`      | `SDCARD_SS_PIN`   |
+| `IO5`             | `GPIO5`      |                   |
+| `IO6`             | `GPIO6`      |                   |
+| `IO7`             | `GPIO7`      |                   |
+| `IO8`             | `GPIO8`      |                   |
+| `IO9`             | `GPIO9`      |                   |
+| `IO10`            | `GPIO10`     |                   |
+| `IO11`            | `GPIO11`     |                   |
+| `IO12`            | `GPIO12`     |                   |
+| `IO13`            | `GPIO13`     |                   |
+| `IO14`            | `GPIO14`     | `SPI0_CS0_PIN`, `LCD_SS_PIN` |
+| `IO15`            | `GPIO15`     |                   |
+| `IO16`            | `GPIO16`     | `UART1_RX_PIN`    |
+| `IO17`            | `GPIO17`     | `UART1_TX_PIN`    |
+| `IO18`            | `GPIO18`     | `SPI0_SCK_PIN`, `LCD_SCK_PIN`, `SDCARD_SCK_PIN` |
+| `IO19`            | `GPIO19`     | `SPI0_SDI_PIN`, `LCD_SDI_PIN`, `SDCARD_SDI_PIN` |
+| `IO21`            | `GPIO21`     | `SDA0_PIN`, `SDA_PIN` |
+| `IO22`            | `GPIO22`     | `SCL0_PIN`, `SCL_PIN` |
+| `IO23`            | `GPIO23`     | `SPI0_SDO_PIN`, `LCD_SDO_PIN`, `SDCARD_SDO_PIN` |
+| `IO25`            | `GPIO25`     | `SPEAKER_PIN`, `DAC1` |
+| `IO26`            | `GPIO26`     | `DAC2`            |
+| `IO27`            | `GPIO27`     | `LCD_DC_PIN`      |
+| `IO32`            | `GPIO32`     | `LCD_BL_PIN`      |
+| `IO33`            | `GPIO33`     | `LCD_RST_PIN`     |
+| `IO34`            | `GPIO34`     |                   |
+| `IO35`            | `GPIO35`     | `ADC1`            |
+| `IO36`            | `GPIO36`     | `ADC2`            |
+| `IO37`            | `GPIO37`     | `BUTTON_C`        |
+| `IO38`            | `GPIO38`     | `BUTTON_B`        |
+| `IO39`            | `GPIO39`     | `BUTTON_A`, `BUTTON` |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the M5Stack Core2](../machine/m5stack)
+
+## Flashing
+
+### CLI Flashing on Linux
+
+You need to install the `esptool` flashing tool:
+
+https://github.com/espressif/esptool#easy-installation
+
+Now you should be able to flash your board as follows:
+
+- Plug your ESP32 board into your computer's USB port.
+- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the ESP32 with the serial example:
+
+    ```
+    tinygo flash -target=m5stack -port=/dev/ttyUSB0 examples/serial
+    ```
+
+- The ESP32 board should restart and then begin running your program.
+
+### CLI Flashing on macOS
+
+You need to install the `esptool` flashing tool:
+
+https://github.com/espressif/esptool#easy-installation
+
+Now you should be able to flash your board as follows:
+
+- Plug your ESP32 board into your computer's USB port.
+- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the ESP32 with the serial example:
+
+    ```
+    tinygo flash -target=m5stack examples/serial
+    ```
+
+- The ESP32 board should restart and then begin running your program.
+
+### CLI Flashing on Windows
+
+You need to install the `esptool` flashing tool:
+
+https://github.com/espressif/esptool#easy-installation
+
+Now you should be able to flash your board as follows:
+
+- Plug your ESP32 board into your computer's USB port.
+- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the ESP32 with the serial example:
+
+    ```
+    tinygo flash -target=m5stack examples/serial
+    ```
+
+- The ESP32 board should restart and then begin running your program.
+
+### Troubleshooting
+
+Goes here
+
+## Notes
+
+Goes here
diff --git a/content/docs/reference/microcontrollers/m5stamp-c3.md b/content/docs/reference/microcontrollers/m5stamp-c3.md
new file mode 100644
index 00000000..00d94eaf
--- /dev/null
+++ b/content/docs/reference/microcontrollers/m5stamp-c3.md
@@ -0,0 +1,78 @@
+---
+title: "M5Stamp C3"
+weight: 3
+---
+
+The [M5Stamp-C3](https://docs.m5stack.com/en/core/stamp_c3) is a development board based on the Espressif ESP32-C3 a powerful chip that is used on many different board mostly because of the built-in radio that can be used for WiFi or Bluetooth wireless connections.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | Not yet |
+| ADC       | YES | YES |
+| PWM       | YES | Not yet |
+| USBDevice | YES | Not yet |
+| WiFi      | YES | Not Yet |
+| Bluetooth | YES | Not yet |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `IO0`             | `GPIO0`      | `XTAL_32K_P`      |
+| `IO1`             | `GPIO1`      | `XTAL_32K_N`      |
+| `IO2`             | `GPIO2`      | `WS2812`          |
+| `IO3`             | `GPIO3`      |                   |
+| `IO4`             | `GPIO4`      | `MTMS`            |
+| `IO5`             | `GPIO5`      | `MTDI`            |
+| `IO6`             | `GPIO6`      | `MTCK`            |
+| `IO7`             | `GPIO7`      | `MTDO`            |
+| `IO8`             | `GPIO8`      |                   |
+| `IO9`             | `GPIO9`      |                   |
+| `IO10`            | `GPIO10`     |                   |
+| `IO11`            | `GPIO11`     | `VDD_SPI`         |
+| `IO12`            | `GPIO12`     | `SPIHD`           |
+| `IO13`            | `GPIO13`     | `SPISP`           |
+| `IO14`            | `GPIO14`     | `SPICS0`          |
+| `IO15`            | `GPIO15`     | `SPICLK`          |
+| `IO16`            | `GPIO16`     | `SPID`            |
+| `IO17`            | `GPIO17`     | `SPIQ`            |
+| `IO18`            | `GPIO18`     |                   |
+| `IO19`            | `GPIO19`     |                   |
+| `IO20`            | `GPIO20`     | `U0RXD`, `UART_RX_PIN` |
+| `IO21`            | `GPIO21`     | `U0TXD`, `UART_TX_PIN` |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the M5Stamp-C3](../machine/m5stamp-c3)
+
+## Flashing
+
+### CLI Flashing
+
+In addition, you must install the `esptool` flashing tool:
+
+https://github.com/espressif/esptool#easy-installation
+
+Now you should be able to flash your board as follows:
+
+- Plug your ESP32-C3 board into your computer's USB port.
+- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the ESP32-C3 with the serial example:
+
+    ```
+    tinygo flash -target=m5stack-core2 examples/serial
+    ```
+
+- The ESP32-C3 board should restart and then begin running your program.
+
+### Troubleshooting
+
+Goes here
+
+## Notes
+
+Goes here
diff --git a/content/microcontrollers/machine/_index.md b/content/docs/reference/microcontrollers/machine/_index.md
similarity index 100%
rename from content/microcontrollers/machine/_index.md
rename to content/docs/reference/microcontrollers/machine/_index.md
diff --git a/content/docs/reference/microcontrollers/machine/arduino-mega1280.md b/content/docs/reference/microcontrollers/machine/arduino-mega1280.md
new file mode 100644
index 00000000..9e31872d
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/arduino-mega1280.md
@@ -0,0 +1,1225 @@
+
+---
+title: arduino-mega1280
+---
+
+
+## Constants
+
+```go
+const (
+	A0	Pin	= PF0
+	A1	Pin	= PF1
+	A2	Pin	= PF2
+	A3	Pin	= PF3
+	A4	Pin	= PF4
+	A5	Pin	= PF5
+	A6	Pin	= PF6
+	A7	Pin	= PF7
+	A8	Pin	= PK0
+	A9	Pin	= PK1
+	A10	Pin	= PK2
+	A11	Pin	= PK3
+	A12	Pin	= PK4
+	A13	Pin	= PK5
+	A14	Pin	= PK6
+	A15	Pin	= PK7
+
+	// Analog Input
+	ADC0	Pin	= PF0
+	ADC1	Pin	= PF1
+	ADC2	Pin	= PF2
+	ADC3	Pin	= PF3
+	ADC4	Pin	= PF4
+	ADC5	Pin	= PF5
+	ADC6	Pin	= PF6
+	ADC7	Pin	= PF7
+	ADC8	Pin	= PK0
+	ADC9	Pin	= PK1
+	ADC10	Pin	= PK2
+	ADC11	Pin	= PK3
+	ADC12	Pin	= PK4
+	ADC13	Pin	= PK5
+	ADC14	Pin	= PK6
+	ADC15	Pin	= PK7
+
+	// Digital pins
+	D0	Pin	= PE0
+	D1	Pin	= PE1
+	D2	Pin	= PE4
+	D3	Pin	= PE5
+	D4	Pin	= PG5
+	D5	Pin	= PE3
+	D6	Pin	= PH3
+	D7	Pin	= PH4
+	D8	Pin	= PH5
+	D9	Pin	= PH6
+	D10	Pin	= PB4
+	D11	Pin	= PB5
+	D12	Pin	= PB6
+	D13	Pin	= PB7
+	D14	Pin	= PJ1
+	D15	Pin	= PJ0
+	D16	Pin	= PH1
+	D17	Pin	= PH0
+	D18	Pin	= PD3
+	D19	Pin	= PD2
+	D20	Pin	= PD1
+	D21	Pin	= PD0
+	D22	Pin	= PA0
+	D23	Pin	= PA1
+	D24	Pin	= PA2
+	D25	Pin	= PA3
+	D26	Pin	= PA4
+	D27	Pin	= PA5
+	D28	Pin	= PA6
+	D29	Pin	= PA7
+	D30	Pin	= PC7
+	D31	Pin	= PC6
+	D32	Pin	= PC5
+	D33	Pin	= PC4
+	D34	Pin	= PC3
+	D35	Pin	= PC2
+	D36	Pin	= PC1
+	D37	Pin	= PC0
+	D38	Pin	= PD7
+	D39	Pin	= PG2
+	D40	Pin	= PG1
+	D41	Pin	= PG0
+	D42	Pin	= PL7
+	D43	Pin	= PL6
+	D44	Pin	= PL5
+	D45	Pin	= PL4
+	D46	Pin	= PL3
+	D47	Pin	= PL2
+	D48	Pin	= PL1
+	D49	Pin	= PL0
+	D50	Pin	= PB3
+	D51	Pin	= PB2
+	D52	Pin	= PB1
+	D53	Pin	= PB0
+
+	AREF	Pin	= NoPin
+	LED	Pin	= PB7
+)
+```
+
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PA0	= portA + 0
+	PA1	= portA + 1
+	PA2	= portA + 2
+	PA3	= portA + 3
+	PA4	= portA + 4
+	PA5	= portA + 5
+	PA6	= portA + 6
+	PA7	= portA + 7
+	PB0	= portB + 0
+	PB1	= portB + 1
+	PB2	= portB + 2
+	PB3	= portB + 3
+	PB4	= portB + 4	// peripherals: Timer2 channel A
+	PB5	= portB + 5	// peripherals: Timer1 channel A
+	PB6	= portB + 6	// peripherals: Timer1 channel B
+	PB7	= portB + 7	// peripherals: Timer0 channel A
+	PC0	= portC + 0
+	PC1	= portC + 1
+	PC2	= portC + 2
+	PC3	= portC + 3
+	PC4	= portC + 4
+	PC5	= portC + 5
+	PC6	= portC + 6
+	PC7	= portC + 7
+	PD0	= portD + 0	// peripherals: I2C0 SCL
+	PD1	= portD + 1	// peripherals: I2C0 SDA
+	PD2	= portD + 2
+	PD3	= portD + 3
+	PD7	= portD + 7
+	PE0	= portE + 0
+	PE1	= portE + 1
+	PE3	= portE + 3	// peripherals: Timer3 channel A
+	PE4	= portE + 4	// peripherals: Timer3 channel B
+	PE5	= portE + 5	// peripherals: Timer3 channel C
+	PE6	= portE + 6
+	PF0	= portF + 0
+	PF1	= portF + 1
+	PF2	= portF + 2
+	PF3	= portF + 3
+	PF4	= portF + 4
+	PF5	= portF + 5
+	PF6	= portF + 6
+	PF7	= portF + 7
+	PG0	= portG + 0
+	PG1	= portG + 1
+	PG2	= portG + 2
+	PG5	= portG + 5	// peripherals: Timer0 channel B
+	PH0	= portH + 0
+	PH1	= portH + 1
+	PH3	= portH + 3	// peripherals: Timer4 channel A
+	PH4	= portH + 4	// peripherals: Timer4 channel B
+	PH5	= portH + 5	// peripherals: Timer4 channel C
+	PH6	= portH + 6	// peripherals: Timer0 channel B
+	PJ0	= portJ + 0
+	PJ1	= portJ + 1
+	PK0	= portK + 0
+	PK1	= portK + 1
+	PK2	= portK + 2
+	PK3	= portK + 3
+	PK4	= portK + 4
+	PK5	= portK + 5
+	PK6	= portK + 6
+	PK7	= portK + 7
+	PL0	= portL + 0
+	PL1	= portL + 1
+	PL2	= portL + 2
+	PL3	= portL + 3	// peripherals: Timer5 channel A
+	PL4	= portL + 4	// peripherals: Timer5 channel B
+	PL5	= portL + 5	// peripherals: Timer5 channel C
+	PL6	= portL + 6
+	PL7	= portL + 7
+)
+```
+
+
+
+```go
+const (
+	PinInput	PinMode	= iota
+	PinInputPullup
+	PinOutput
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var DefaultUART = UART0
+```
+
+Always use UART0 as the serial output.
+
+
+```go
+var (
+	// UART0 is the hardware serial port on the AVR.
+	UART0	= &_UART0
+	_UART0	= UART{
+		Buffer:	NewRingBuffer(),
+
+		dataReg:	avr.UDR0,
+		baudRegH:	avr.UBRR0H,
+		baudRegL:	avr.UBRR0L,
+		statusRegA:	avr.UCSR0A,
+		statusRegB:	avr.UCSR0B,
+		statusRegC:	avr.UCSR0C,
+	}
+)
+```
+
+UART
+
+
+```go
+var (
+	Timer0	= PWM{0}	// 8 bit timer for PB7 and PG5
+	Timer1	= PWM{1}	// 16 bit timer for PB5 and PB6
+	Timer2	= PWM{2}	// 8 bit timer for PB4 and PH6
+	Timer3	= PWM{3}	// 16 bit timer for PE3, PE4 and PE5
+	Timer4	= PWM{4}	// 16 bit timer for PH3, PH4 and PH5
+	Timer5	= PWM{5}	// 16 bit timer for PL3, PL4 and PL5
+)
+```
+
+
+
+```go
+var SPI0 = &SPI{
+	spcr:	avr.SPCR,
+	spdr:	avr.SPDR,
+	spsr:	avr.SPSR,
+	sck:	PB1,
+	sdo:	PB2,
+	sdi:	PB3,
+	cs:	PB0}
+```
+
+SPI configuration
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+Return the current CPU frequency in hertz.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(ADCConfig)
+```
+
+Configure configures a ADCPin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff. The AVR
+has an ADC of 10 bits precision so the lower 6 bits will be zero.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	srReg	*volatile.Register8
+	brReg	*volatile.Register8
+	crReg	*volatile.Register8
+	drReg	*volatile.Register8
+
+	srPS0	byte
+	srPS1	byte
+	crEN	byte
+	crINT	byte
+	crSTO	byte
+	crEA	byte
+	crSTA	byte
+}
+```
+
+I2C on AVR.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency uint32
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWM
+
+```go
+type PWM struct {
+	num uint8
+}
+```
+
+PWM is one PWM peripheral, which consists of a counter and two output
+channels (that can be connected to two fixed pins). You can set the frequency
+using SetPeriod, but only for all the channels in this PWM peripheral at
+once.
+
+
+
+### func (PWM) Channel
+
+```go
+func (pwm PWM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (PWM) Configure
+
+```go
+func (pwm PWM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+
+For the two 8 bit timers, there is only a limited number of periods
+available, namely the CPU frequency divided by 256 and again divided by 1, 8,
+64, 256, or 1024. For a MCU running at 16MHz, this would be a period of 16µs,
+128µs, 1024µs, 4096µs, or 16384µs.
+
+
+### func (PWM) Counter
+
+```go
+func (pwm PWM) Counter() uint32
+```
+
+Counter returns the current counter value of the timer in this PWM
+peripheral. It may be useful for debugging.
+
+
+### func (PWM) Period
+
+```go
+func (pwm PWM) Period() uint64
+```
+
+Period returns the used PWM period in nanoseconds. It might deviate slightly
+from the configured period due to rounding.
+
+
+### func (PWM) Set
+
+```go
+func (pwm PWM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle, in other words the fraction of time the channel output is high (or low
+when inverted). For example, to set it to a 25% duty cycle, use:
+
+	pwm.Set(channel, pwm.Top() / 4)
+
+pwm.Set(channel, 0) will set the output to low and pwm.Set(channel,
+pwm.Top()) will set the output to high, assuming the output isn't inverted.
+
+
+### func (PWM) SetInverting
+
+```go
+func (pwm PWM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+Note: the invert state may not be applied on the AVR until the next call to
+ch.Set().
+
+
+### func (PWM) SetPeriod
+
+```go
+func (pwm PWM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (PWM) Top
+
+```go
+func (pwm PWM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to Set
+(see Set documentation for more information).
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure sets the pin to input or output.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*volatile.Register8, uint8)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+Warning: there are no separate pin set/clear registers on the AVR. The
+returned mask is only valid as long as no other pin in the same port has been
+changed.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*volatile.Register8, uint8)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+Warning: there are no separate pin set/clear registers on the AVR. The
+returned mask is only valid as long as no other pin in the same port has been
+changed.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set changes the value of the GPIO pin. The pin must be configured as output.
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	// The registers for the SPIx port set by the chip
+	spcr	*volatile.Register8
+	spdr	*volatile.Register8
+	spsr	*volatile.Register8
+
+	spcrR0		byte
+	spcrR1		byte
+	spcrCPHA	byte
+	spcrCPOL	byte
+	spcrDORD	byte
+	spcrSPE		byte
+	spcrMSTR	byte
+
+	spsrI2X		byte
+	spsrSPIF	byte
+
+	// The io pins for the SPIx port set by the chip
+	sck	Pin
+	sdi	Pin
+	sdo	Pin
+	cs	Pin
+}
+```
+
+SPI is for the Serial Peripheral Interface
+Data is taken from http://ww1.microchip.com/downloads/en/DeviceDoc/ATmega48A-PA-88A-PA-168A-PA-328-P-DS-DS40002061A.pdf page 169 and following
+
+
+
+### func (*SPI) Configure
+
+```go
+func (s *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (s *SPI) Transfer(b byte) (byte, error)
+```
+
+Transfer writes the byte into the register and returns the read content
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer	*RingBuffer
+
+	dataReg		*volatile.Register8
+	baudRegH	*volatile.Register8
+	baudRegL	*volatile.Register8
+
+	statusRegA	*volatile.Register8
+	statusRegB	*volatile.Register8
+	statusRegC	*volatile.Register8
+}
+```
+
+UART on the AVR.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART on the AVR. Defaults to 9600 baud on Arduino.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/arduino-mega2560.md b/content/docs/reference/microcontrollers/machine/arduino-mega2560.md
new file mode 100644
index 00000000..edbff3fc
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/arduino-mega2560.md
@@ -0,0 +1,1140 @@
+
+---
+title: arduino-mega2560
+---
+
+
+## Constants
+
+```go
+const (
+	A0	Pin	= PF0
+	A1	Pin	= PF1
+	A2	Pin	= PF2
+	A3	Pin	= PF3
+	A4	Pin	= PF4
+	A5	Pin	= PF5
+	A6	Pin	= PF6
+	A7	Pin	= PF7
+	A8	Pin	= PK0
+	A9	Pin	= PK1
+	A10	Pin	= PK2
+	A11	Pin	= PK3
+	A12	Pin	= PK4
+	A13	Pin	= PK5
+	A14	Pin	= PK6
+	A15	Pin	= PK7
+
+	// Analog Input
+	ADC0	Pin	= PF0
+	ADC1	Pin	= PF1
+	ADC2	Pin	= PF2
+	ADC3	Pin	= PF3
+	ADC4	Pin	= PF4
+	ADC5	Pin	= PF5
+	ADC6	Pin	= PF6
+	ADC7	Pin	= PF7
+	ADC8	Pin	= PK0
+	ADC9	Pin	= PK1
+	ADC10	Pin	= PK2
+	ADC11	Pin	= PK3
+	ADC12	Pin	= PK4
+	ADC13	Pin	= PK5
+	ADC14	Pin	= PK6
+	ADC15	Pin	= PK7
+
+	// Digital pins
+	D0	Pin	= PE0
+	D1	Pin	= PE1
+	D2	Pin	= PE4
+	D3	Pin	= PE5
+	D4	Pin	= PG5
+	D5	Pin	= PE3
+	D6	Pin	= PH3
+	D7	Pin	= PH4
+	D8	Pin	= PH5
+	D9	Pin	= PH6
+	D10	Pin	= PB4
+	D11	Pin	= PB5
+	D12	Pin	= PB6
+	D13	Pin	= PB7
+	D14	Pin	= PJ1	// TX3
+	D15	Pin	= PJ0	// RX3
+	D16	Pin	= PH1	// TX2
+	D17	Pin	= PH0	// RX2
+	D18	Pin	= PD3	// TX1
+	D19	Pin	= PD2	// RX1
+	D20	Pin	= PD1
+	D21	Pin	= PD0
+	D22	Pin	= PA0
+	D23	Pin	= PA1
+	D24	Pin	= PA2
+	D25	Pin	= PA3
+	D26	Pin	= PA4
+	D27	Pin	= PA5
+	D28	Pin	= PA6
+	D29	Pin	= PA7
+	D30	Pin	= PC7
+	D31	Pin	= PC6
+	D32	Pin	= PC5
+	D33	Pin	= PC4
+	D34	Pin	= PC3
+	D35	Pin	= PC2
+	D36	Pin	= PC1
+	D37	Pin	= PC0
+	D38	Pin	= PD7
+	D39	Pin	= PG2
+	D40	Pin	= PG1
+	D41	Pin	= PG0
+	D42	Pin	= PL7
+	D43	Pin	= PL6
+	D44	Pin	= PL5
+	D45	Pin	= PL4
+	D46	Pin	= PL3
+	D47	Pin	= PL2
+	D48	Pin	= PL1
+	D49	Pin	= PL0
+	D50	Pin	= PB3
+	D51	Pin	= PB2
+	D52	Pin	= PB1
+	D53	Pin	= PB0
+
+	AREF	Pin	= NoPin
+	LED	Pin	= PB7
+)
+```
+
+
+
+```go
+const (
+	UART_TX_PIN	Pin	= UART0_TX_PIN
+	UART_RX_PIN	Pin	= UART0_RX_PIN
+	UART0_TX_PIN	Pin	= D1
+	UART0_RX_PIN	Pin	= D0
+	UART1_TX_PIN	Pin	= D18
+	UART1_RX_PIN	Pin	= D19
+	UART2_TX_PIN	Pin	= D16
+	UART2_RX_PIN	Pin	= D17
+	UART3_TX_PIN	Pin	= D14
+	UART3_RX_PIN	Pin	= D15
+)
+```
+
+UART pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PA0	= portA + 0
+	PA1	= portA + 1
+	PA2	= portA + 2
+	PA3	= portA + 3
+	PA4	= portA + 4
+	PA5	= portA + 5
+	PA6	= portA + 6
+	PA7	= portA + 7
+	PB0	= portB + 0
+	PB1	= portB + 1
+	PB2	= portB + 2
+	PB3	= portB + 3
+	PB4	= portB + 4
+	PB5	= portB + 5
+	PB6	= portB + 6
+	PB7	= portB + 7
+	PC0	= portC + 0
+	PC1	= portC + 1
+	PC2	= portC + 2
+	PC3	= portC + 3
+	PC4	= portC + 4
+	PC5	= portC + 5
+	PC6	= portC + 6
+	PC7	= portC + 7
+	PD0	= portD + 0
+	PD1	= portD + 1
+	PD2	= portD + 2
+	PD3	= portD + 3
+	PD7	= portD + 7
+	PE0	= portE + 0
+	PE1	= portE + 1
+	PE3	= portE + 3
+	PE4	= portE + 4
+	PE5	= portE + 5
+	PE6	= portE + 6
+	PF0	= portF + 0
+	PF1	= portF + 1
+	PF2	= portF + 2
+	PF3	= portF + 3
+	PF4	= portF + 4
+	PF5	= portF + 5
+	PF6	= portF + 6
+	PF7	= portF + 7
+	PG0	= portG + 0
+	PG1	= portG + 1
+	PG2	= portG + 2
+	PG5	= portG + 5
+	PH0	= portH + 0
+	PH1	= portH + 1
+	PH3	= portH + 3
+	PH4	= portH + 4
+	PH5	= portH + 5
+	PH6	= portH + 6
+	PJ0	= portJ + 0
+	PJ1	= portJ + 1
+	PK0	= portK + 0
+	PK1	= portK + 1
+	PK2	= portK + 2
+	PK3	= portK + 3
+	PK4	= portK + 4
+	PK5	= portK + 5
+	PK6	= portK + 6
+	PK7	= portK + 7
+	PL0	= portL + 0
+	PL1	= portL + 1
+	PL2	= portL + 2
+	PL3	= portL + 3
+	PL4	= portL + 4
+	PL5	= portL + 5
+	PL6	= portL + 6
+	PL7	= portL + 7
+)
+```
+
+
+
+```go
+const (
+	PinInput	PinMode	= iota
+	PinInputPullup
+	PinOutput
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:	NewRingBuffer(),
+
+		dataReg:	avr.UDR1,
+		baudRegH:	avr.UBRR1H,
+		baudRegL:	avr.UBRR1L,
+		statusRegA:	avr.UCSR1A,
+		statusRegB:	avr.UCSR1B,
+		statusRegC:	avr.UCSR1C,
+	}
+	UART2	= &_UART2
+	_UART2	= UART{
+		Buffer:	NewRingBuffer(),
+
+		dataReg:	avr.UDR2,
+		baudRegH:	avr.UBRR2H,
+		baudRegL:	avr.UBRR2L,
+		statusRegA:	avr.UCSR2A,
+		statusRegB:	avr.UCSR2B,
+		statusRegC:	avr.UCSR2C,
+	}
+	UART3	= &_UART3
+	_UART3	= UART{
+		Buffer:	NewRingBuffer(),
+
+		dataReg:	avr.UDR3,
+		baudRegH:	avr.UBRR3H,
+		baudRegL:	avr.UBRR3L,
+		statusRegA:	avr.UCSR3A,
+		statusRegB:	avr.UCSR3B,
+		statusRegC:	avr.UCSR3C,
+	}
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var DefaultUART = UART0
+```
+
+Always use UART0 as the serial output.
+
+
+```go
+var (
+	// UART0 is the hardware serial port on the AVR.
+	UART0	= &_UART0
+	_UART0	= UART{
+		Buffer:	NewRingBuffer(),
+
+		dataReg:	avr.UDR0,
+		baudRegH:	avr.UBRR0H,
+		baudRegL:	avr.UBRR0L,
+		statusRegA:	avr.UCSR0A,
+		statusRegB:	avr.UCSR0B,
+		statusRegC:	avr.UCSR0C,
+	}
+)
+```
+
+UART
+
+
+```go
+var SPI0 = &SPI{
+	spcr:	avr.SPCR,
+	spdr:	avr.SPDR,
+	spsr:	avr.SPSR,
+	sck:	PB1,
+	sdo:	PB2,
+	sdi:	PB3,
+	cs:	PB0}
+```
+
+SPI configuration
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+Return the current CPU frequency in hertz.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(ADCConfig)
+```
+
+Configure configures a ADCPin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff. The AVR
+has an ADC of 10 bits precision so the lower 6 bits will be zero.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	srReg	*volatile.Register8
+	brReg	*volatile.Register8
+	crReg	*volatile.Register8
+	drReg	*volatile.Register8
+
+	srPS0	byte
+	srPS1	byte
+	crEN	byte
+	crINT	byte
+	crSTO	byte
+	crEA	byte
+	crSTA	byte
+}
+```
+
+I2C on AVR.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency uint32
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure sets the pin to input or output.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*volatile.Register8, uint8)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+Warning: there are no separate pin set/clear registers on the AVR. The
+returned mask is only valid as long as no other pin in the same port has been
+changed.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*volatile.Register8, uint8)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+Warning: there are no separate pin set/clear registers on the AVR. The
+returned mask is only valid as long as no other pin in the same port has been
+changed.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set changes the value of the GPIO pin. The pin must be configured as output.
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	// The registers for the SPIx port set by the chip
+	spcr	*volatile.Register8
+	spdr	*volatile.Register8
+	spsr	*volatile.Register8
+
+	spcrR0		byte
+	spcrR1		byte
+	spcrCPHA	byte
+	spcrCPOL	byte
+	spcrDORD	byte
+	spcrSPE		byte
+	spcrMSTR	byte
+
+	spsrI2X		byte
+	spsrSPIF	byte
+
+	// The io pins for the SPIx port set by the chip
+	sck	Pin
+	sdi	Pin
+	sdo	Pin
+	cs	Pin
+}
+```
+
+SPI is for the Serial Peripheral Interface
+Data is taken from http://ww1.microchip.com/downloads/en/DeviceDoc/ATmega48A-PA-88A-PA-168A-PA-328-P-DS-DS40002061A.pdf page 169 and following
+
+
+
+### func (*SPI) Configure
+
+```go
+func (s *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (s *SPI) Transfer(b byte) (byte, error)
+```
+
+Transfer writes the byte into the register and returns the read content
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer	*RingBuffer
+
+	dataReg		*volatile.Register8
+	baudRegH	*volatile.Register8
+	baudRegL	*volatile.Register8
+
+	statusRegA	*volatile.Register8
+	statusRegB	*volatile.Register8
+	statusRegC	*volatile.Register8
+}
+```
+
+UART on the AVR.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART on the AVR. Defaults to 9600 baud on Arduino.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/arduino-mkr1000.md b/content/docs/reference/microcontrollers/machine/arduino-mkr1000.md
new file mode 100644
index 00000000..38bbee17
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/arduino-mkr1000.md
@@ -0,0 +1,1722 @@
+
+---
+title: arduino-mkr1000
+---
+
+
+## Constants
+
+```go
+const (
+	D0	Pin	= PA22	// PWM available
+	D1	Pin	= PA23	// PWM available
+	D2	Pin	= PA10	// PWM available
+	D3	Pin	= PA11	// PWM available
+	D4	Pin	= PB10	// PWM available
+	D5	Pin	= PB11	// PWM available
+
+	D6	Pin	= PA20	// PWM available
+	D7	Pin	= PA21	// PWM available
+	D8	Pin	= PA16	// PWM available
+	D9	Pin	= PA17
+	D10	Pin	= PA19	// PWM available
+	D11	Pin	= PA08	// SDA
+	D12	Pin	= PA09	// PWM available, SCL
+	D13	Pin	= PB23	// RX
+	D14	Pin	= PB22	// TX
+
+	RX0	Pin	= PB23	// UART2 RX
+	TX1	Pin	= PB22	// UART2 TX
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A0	Pin	= PA02	// ADC0/AIN[0]
+	A1	Pin	= PB02	// AIN[10]
+	A2	Pin	= PB03	// AIN[11]
+	A3	Pin	= PA04	// AIN[04]
+	A4	Pin	= PA05	// AIN[05]
+	A5	Pin	= PA06	// AIN[06]
+	A6	Pin	= PA07	// AIN[07]
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	LED = D6
+)
+```
+
+
+
+```go
+const (
+	USBCDC_DM_PIN	Pin	= PA24
+	USBCDC_DP_PIN	Pin	= PA25
+)
+```
+
+USBCDC pins
+
+
+```go
+const (
+	UART_TX_PIN	Pin	= PB22
+	UART_RX_PIN	Pin	= PB23
+)
+```
+
+UART1 pins
+
+
+```go
+const (
+	SDA_PIN	Pin	= D11	// SDA
+	SCL_PIN	Pin	= D12	// SCL
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	Pin	= D9	// SCK: S1
+	SPI0_SDO_PIN	Pin	= D8	// SDO: S1
+	SPI0_SDI_PIN	Pin	= D10	// SDI: S1
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	I2S_SCK_PIN	Pin	= PA10
+	I2S_SDO_PIN	Pin	= PA07
+	I2S_SDI_PIN		= NoPin
+	I2S_WS_PIN		= NoPin	// TODO: figure out what this is on Arduino MKR1000
+)
+```
+
+I2S pins
+
+
+```go
+const (
+	PA00	Pin	= 0	// peripherals: TCC2 channel 0, sercomI2CM1 SDA
+	PA01	Pin	= 1	// peripherals: TCC2 channel 1, sercomI2CM1 SCL
+	PA02	Pin	= 2
+	PA03	Pin	= 3
+	PA04	Pin	= 4	// peripherals: TCC0 channel 0
+	PA05	Pin	= 5	// peripherals: TCC0 channel 1
+	PA06	Pin	= 6	// peripherals: TCC1 channel 0
+	PA07	Pin	= 7	// peripherals: TCC1 channel 1
+	PA08	Pin	= 8	// peripherals: TCC0 channel 0, TCC1 channel 2, sercomI2CM0 SDA, sercomI2CM2 SDA
+	PA09	Pin	= 9	// peripherals: TCC0 channel 1, TCC1 channel 3, sercomI2CM0 SCL, sercomI2CM2 SCL
+	PA10	Pin	= 10	// peripherals: TCC1 channel 0, TCC0 channel 2
+	PA11	Pin	= 11	// peripherals: TCC1 channel 1, TCC0 channel 3
+	PA12	Pin	= 12	// peripherals: TCC2 channel 0, TCC0 channel 2, sercomI2CM2 SDA, sercomI2CM4 SDA
+	PA13	Pin	= 13	// peripherals: TCC2 channel 1, TCC0 channel 3, sercomI2CM2 SCL, sercomI2CM4 SCL
+	PA14	Pin	= 14	// peripherals: TCC0 channel 0
+	PA15	Pin	= 15	// peripherals: TCC0 channel 1
+	PA16	Pin	= 16	// peripherals: TCC2 channel 0, TCC0 channel 2, sercomI2CM1 SDA, sercomI2CM3 SDA
+	PA17	Pin	= 17	// peripherals: TCC2 channel 1, TCC0 channel 3, sercomI2CM1 SCL, sercomI2CM3 SCL
+	PA18	Pin	= 18	// peripherals: TCC0 channel 2
+	PA19	Pin	= 19	// peripherals: TCC0 channel 3
+	PA20	Pin	= 20	// peripherals: TCC0 channel 2
+	PA21	Pin	= 21	// peripherals: TCC0 channel 3
+	PA22	Pin	= 22	// peripherals: TCC0 channel 0, sercomI2CM3 SDA, sercomI2CM5 SDA
+	PA23	Pin	= 23	// peripherals: TCC0 channel 1, sercomI2CM3 SCL, sercomI2CM5 SCL
+	PA24	Pin	= 24	// peripherals: TCC1 channel 2
+	PA25	Pin	= 25	// peripherals: TCC1 channel 3
+	PA26	Pin	= 26
+	PA27	Pin	= 27
+	PA28	Pin	= 28
+	PA29	Pin	= 29
+	PA30	Pin	= 30	// peripherals: TCC1 channel 0
+	PA31	Pin	= 31	// peripherals: TCC1 channel 1
+	PB00	Pin	= 32
+	PB01	Pin	= 33
+	PB02	Pin	= 34	// peripherals: sercomI2CM5 SDA
+	PB03	Pin	= 35	// peripherals: sercomI2CM5 SCL
+	PB04	Pin	= 36
+	PB05	Pin	= 37
+	PB06	Pin	= 38
+	PB07	Pin	= 39
+	PB08	Pin	= 40	// peripherals: sercomI2CM4 SDA
+	PB09	Pin	= 41	// peripherals: sercomI2CM4 SCL
+	PB10	Pin	= 42	// peripherals: TCC0 channel 0
+	PB11	Pin	= 43	// peripherals: TCC0 channel 1
+	PB12	Pin	= 44	// peripherals: TCC0 channel 2, sercomI2CM4 SDA
+	PB13	Pin	= 45	// peripherals: TCC0 channel 3, sercomI2CM4 SCL
+	PB14	Pin	= 46
+	PB15	Pin	= 47
+	PB16	Pin	= 48	// peripherals: TCC0 channel 0, sercomI2CM5 SDA
+	PB17	Pin	= 49	// peripherals: TCC0 channel 1, sercomI2CM5 SCL
+	PB18	Pin	= 50
+	PB19	Pin	= 51
+	PB20	Pin	= 52
+	PB21	Pin	= 53
+	PB22	Pin	= 54
+	PB23	Pin	= 55
+	PB24	Pin	= 56
+	PB25	Pin	= 57
+	PB26	Pin	= 58
+	PB27	Pin	= 59
+	PB28	Pin	= 60
+	PB29	Pin	= 61
+	PB30	Pin	= 62	// peripherals: TCC0 channel 0, TCC1 channel 2, sercomI2CM5 SDA
+	PB31	Pin	= 63	// peripherals: TCC0 channel 1, TCC1 channel 3, sercomI2CM5 SCL
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const (
+	I2SModeSource	I2SMode	= iota
+	I2SModeReceiver
+	I2SModePDM
+	I2SModeSourceReceiver
+)
+```
+
+
+
+```go
+const (
+	I2StandardPhilips	I2SStandard	= iota
+	I2SStandardMSB
+	I2SStandardLSB
+)
+```
+
+
+
+```go
+const (
+	I2SClockSourceInternal	I2SClockSource	= iota
+	I2SClockSourceExternal
+)
+```
+
+
+
+```go
+const (
+	I2SDataFormatDefault	I2SDataFormat	= 0
+	I2SDataFormat8bit			= 8
+	I2SDataFormat16bit			= 16
+	I2SDataFormat24bit			= 24
+	I2SDataFormat32bit			= 32
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinAnalog	PinMode	= 1
+	PinSERCOM	PinMode	= 2
+	PinSERCOMAlt	PinMode	= 3
+	PinTimer	PinMode	= 4
+	PinTimerAlt	PinMode	= 5
+	PinCom		PinMode	= 6
+	//PinAC_CLK        PinMode = 7
+	PinDigital		PinMode	= 8
+	PinInput		PinMode	= 9
+	PinInputPullup		PinMode	= 10
+	PinOutput		PinMode	= 11
+	PinTCC			PinMode	= PinTimer
+	PinTCCAlt		PinMode	= PinTimerAlt
+	PinInputPulldown	PinMode	= 12
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
+	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
+	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (16s)
+	WatchdogMaxTimeout = (16384 * 1000) / 1024
+)
+```
+
+
+
+```go
+const (
+	// these are SAMD21 specific.
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Pos	= 0
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Mask	= 0x3FFF
+
+	usb_DEVICE_PCKSIZE_SIZE_Pos	= 28
+	usb_DEVICE_PCKSIZE_SIZE_Mask	= 0x7
+
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Pos	= 14
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Mask	= 0x3FFF
+
+	NumberOfUSBEndpoints	= 8
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	ErrInvalidSampleFrequency = errors.New("i2s: invalid sample frequency")
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var I2S0 = I2S{Bus: sam.I2S}
+```
+
+
+
+```go
+var (
+	TCC0	= (*TCC)(sam.TCC0)
+	TCC1	= (*TCC)(sam.TCC1)
+	TCC2	= (*TCC)(sam.TCC2)
+)
+```
+
+The SAM D21 has three TCC peripherals, which have PWM as one feature.
+
+
+```go
+var (
+	DAC0 = DAC{}
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the SAMD21.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+Return the current CPU frequency in hertz.
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) and 16 bytes (128 bits) are common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig)
+```
+
+Configure configures a ADC pin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type DAC
+
+```go
+type DAC struct {
+}
+```
+
+DAC on the SAMD21.
+
+
+
+### func (DAC) Configure
+
+```go
+func (dac DAC) Configure(config DACConfig)
+```
+
+Configure the DAC.
+output pin must already be configured.
+
+
+### func (DAC) Set
+
+```go
+func (dac DAC) Set(value uint16) error
+```
+
+Set writes a single 16-bit value to the DAC.
+Since the ATSAMD21 only has a 10-bit DAC, the passed-in value will be scaled down.
+
+
+
+
+## type DACConfig
+
+```go
+type DACConfig struct {
+}
+```
+
+DACConfig placeholder for future expansion.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*sam.SERCOM_I2CM_Type
+	SERCOM	uint8
+}
+```
+
+I2C on the SAMD21.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteByte
+
+```go
+func (i2c *I2C) WriteByte(data byte) error
+```
+
+WriteByte writes a single byte to the I2C bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type I2S
+
+```go
+type I2S struct {
+	Bus		*sam.I2S_Type
+	Frequency	uint32
+	DataFormat	I2SDataFormat
+}
+```
+
+I2S
+
+
+
+### func (*I2S) Configure
+
+```go
+func (i2s *I2S) Configure(config I2SConfig) error
+```
+
+Configure is used to configure the I2S interface. You must call this
+before you can use the I2S bus.
+
+
+### func (*I2S) Enable
+
+```go
+func (i2s *I2S) Enable(enabled bool)
+```
+
+Enabled is used to enable or disable the I2S bus.
+
+
+### func (*I2S) ReadMono
+
+```go
+func (i2s *I2S) ReadMono(p []uint16) (n int, err error)
+```
+
+Read mono data from the I2S bus into the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) ReadStereo
+
+```go
+func (i2s *I2S) ReadStereo(p []uint32) (n int, err error)
+```
+
+Read stereo data from the I2S bus into the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) SetSampleFrequency
+
+```go
+func (i2s *I2S) SetSampleFrequency(freq uint32) error
+```
+
+SetSampleFrequency is used to set the sample frequency for the I2S bus.
+
+
+### func (*I2S) WriteMono
+
+```go
+func (i2s *I2S) WriteMono(p []uint16) (n int, err error)
+```
+
+Write mono data to the I2S bus from the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) WriteStereo
+
+```go
+func (i2s *I2S) WriteStereo(p []uint32) (n int, err error)
+```
+
+Write stereo data to the I2S bus from the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+
+
+## type I2SClockSource
+
+```go
+type I2SClockSource uint8
+```
+
+
+
+
+
+
+## type I2SConfig
+
+```go
+type I2SConfig struct {
+	// clock
+	SCK	Pin
+	// word select
+	WS	Pin
+	// data out
+	SDO	Pin
+	// data in
+	SDI		Pin
+	Mode		I2SMode
+	Standard	I2SStandard
+	ClockSource	I2SClockSource
+	DataFormat	I2SDataFormat
+	AudioFrequency	uint32
+	MainClockOutput	bool
+	Stereo		bool
+}
+```
+
+All fields are optional and may not be required or used on a particular platform.
+
+
+
+
+
+## type I2SDataFormat
+
+```go
+type I2SDataFormat uint8
+```
+
+
+
+
+
+
+## type I2SMode
+
+```go
+type I2SMode uint8
+```
+
+
+
+
+
+
+## type I2SStandard
+
+```go
+type I2SStandard uint8
+```
+
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when configured as an input or as
+an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*sam.SERCOM_SPI_Type
+	SERCOM	uint8
+}
+```
+
+SPI
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type TCC
+
+```go
+type TCC sam.TCC_Type
+```
+
+TCC is one timer/counter peripheral, which consists of a counter and multiple
+output channels (that can be connected to actual pins). You can set the
+frequency using SetPeriod, but only for all the channels in this TCC
+peripheral at once.
+
+
+
+### func (*TCC) Channel
+
+```go
+func (tcc *TCC) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin. Note that one channel may be
+shared between multiple pins, and so will have the same duty cycle. If this
+is not desirable, look for a different TCC peripheral or consider using a
+different pin.
+
+
+### func (*TCC) Configure
+
+```go
+func (tcc *TCC) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this TCC.
+
+
+### func (*TCC) Counter
+
+```go
+func (tcc *TCC) Counter() uint32
+```
+
+Counter returns the current counter value of the timer in this TCC
+peripheral. It may be useful for debugging.
+
+
+### func (*TCC) Set
+
+```go
+func (tcc *TCC) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle, in other words the fraction of time the channel output is high (or low
+when inverted). For example, to set it to a 25% duty cycle, use:
+
+	tcc.Set(channel, tcc.Top() / 4)
+
+tcc.Set(channel, 0) will set the output to low and tcc.Set(channel,
+tcc.Top()) will set the output to high, assuming the output isn't inverted.
+
+
+### func (*TCC) SetInverting
+
+```go
+func (tcc *TCC) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TCC) SetPeriod
+
+```go
+func (tcc *TCC) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this TCC peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the TCC peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TCC) Top
+
+```go
+func (tcc *TCC) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to Set
+(see Set documentation for more information).
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*sam.SERCOM_USART_Type
+	SERCOM		uint8
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the SAMD21.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/arduino-mkrwifi1010.md b/content/docs/reference/microcontrollers/machine/arduino-mkrwifi1010.md
new file mode 100644
index 00000000..a417f53b
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/arduino-mkrwifi1010.md
@@ -0,0 +1,1775 @@
+
+---
+title: arduino-mkrwifi1010
+---
+
+
+## Constants
+
+```go
+const (
+	D0	Pin	= PA22	// PWM available
+	D1	Pin	= PA23	// PWM available
+	D2	Pin	= PA10	// PWM available
+	D3	Pin	= PA11	// PWM available
+	D4	Pin	= PB10	// PWM available
+	D5	Pin	= PB11	// PWM available
+
+	D6	Pin	= PA20	// PWM available
+	D7	Pin	= PA21	// PWM available
+	D8	Pin	= PA16	// PWM available
+	D9	Pin	= PA17
+	D10	Pin	= PA19	// PWM available
+	D11	Pin	= PA08	// SDA
+	D12	Pin	= PA09	// PWM available, SCL
+	D13	Pin	= PB23	// RX
+	D14	Pin	= PB22	// TX
+
+	RX0	Pin	= PB23	// UART1 RX
+	TX1	Pin	= PB22	// UART1 TX
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A0	Pin	= PA02	// ADC0/AIN[0]
+	A1	Pin	= PB02	// AIN[10]
+	A2	Pin	= PB03	// AIN[11]
+	A3	Pin	= PA04	// AIN[04]
+	A4	Pin	= PA05	// AIN[05]
+	A5	Pin	= PA06	// AIN[06]
+	A6	Pin	= PA07	// AIN[07]
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	LED = D6
+)
+```
+
+
+
+```go
+const (
+	USBCDC_DM_PIN	Pin	= PA24
+	USBCDC_DP_PIN	Pin	= PA25
+)
+```
+
+USBCDC pins
+
+
+```go
+const (
+	UART_TX_PIN	Pin	= PB22
+	UART_RX_PIN	Pin	= PB23
+)
+```
+
+UART1 pins
+
+
+```go
+const (
+	SDA_PIN	Pin	= D11	// SDA
+	SCL_PIN	Pin	= D12	// SCL
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	Pin	= D9	// SCK: S1
+	SPI0_SDO_PIN	Pin	= D8	// SDO: S1
+	SPI0_SDI_PIN	Pin	= D10	// SDI: S1
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	I2S_SCK_PIN	Pin	= PA10
+	I2S_SDO_PIN	Pin	= PA07
+	I2S_SDI_PIN		= NoPin
+	I2S_WS_PIN		= NoPin	// TODO: figure out what this is on Arduino MKR WiFi 1010.
+)
+```
+
+I2S pins
+
+
+```go
+const (
+	NINA_SDO	Pin	= PA12
+	NINA_SDI	Pin	= PA13
+	NINA_CS		Pin	= PA14
+	NINA_SCK	Pin	= PA15
+	NINA_GPIO0	Pin	= PA27
+	NINA_RESETN	Pin	= PB08
+	NINA_ACK	Pin	= PA28
+	NINA_TX		Pin	= PA22
+	NINA_RX		Pin	= PA23
+)
+```
+
+NINA-W102 Pins
+
+
+```go
+const (
+	PA00	Pin	= 0	// peripherals: TCC2 channel 0, sercomI2CM1 SDA
+	PA01	Pin	= 1	// peripherals: TCC2 channel 1, sercomI2CM1 SCL
+	PA02	Pin	= 2
+	PA03	Pin	= 3
+	PA04	Pin	= 4	// peripherals: TCC0 channel 0
+	PA05	Pin	= 5	// peripherals: TCC0 channel 1
+	PA06	Pin	= 6	// peripherals: TCC1 channel 0
+	PA07	Pin	= 7	// peripherals: TCC1 channel 1
+	PA08	Pin	= 8	// peripherals: TCC0 channel 0, TCC1 channel 2, sercomI2CM0 SDA, sercomI2CM2 SDA
+	PA09	Pin	= 9	// peripherals: TCC0 channel 1, TCC1 channel 3, sercomI2CM0 SCL, sercomI2CM2 SCL
+	PA10	Pin	= 10	// peripherals: TCC1 channel 0, TCC0 channel 2
+	PA11	Pin	= 11	// peripherals: TCC1 channel 1, TCC0 channel 3
+	PA12	Pin	= 12	// peripherals: TCC2 channel 0, TCC0 channel 2, sercomI2CM2 SDA, sercomI2CM4 SDA
+	PA13	Pin	= 13	// peripherals: TCC2 channel 1, TCC0 channel 3, sercomI2CM2 SCL, sercomI2CM4 SCL
+	PA14	Pin	= 14	// peripherals: TCC0 channel 0
+	PA15	Pin	= 15	// peripherals: TCC0 channel 1
+	PA16	Pin	= 16	// peripherals: TCC2 channel 0, TCC0 channel 2, sercomI2CM1 SDA, sercomI2CM3 SDA
+	PA17	Pin	= 17	// peripherals: TCC2 channel 1, TCC0 channel 3, sercomI2CM1 SCL, sercomI2CM3 SCL
+	PA18	Pin	= 18	// peripherals: TCC0 channel 2
+	PA19	Pin	= 19	// peripherals: TCC0 channel 3
+	PA20	Pin	= 20	// peripherals: TCC0 channel 2
+	PA21	Pin	= 21	// peripherals: TCC0 channel 3
+	PA22	Pin	= 22	// peripherals: TCC0 channel 0, sercomI2CM3 SDA, sercomI2CM5 SDA
+	PA23	Pin	= 23	// peripherals: TCC0 channel 1, sercomI2CM3 SCL, sercomI2CM5 SCL
+	PA24	Pin	= 24	// peripherals: TCC1 channel 2
+	PA25	Pin	= 25	// peripherals: TCC1 channel 3
+	PA26	Pin	= 26
+	PA27	Pin	= 27
+	PA28	Pin	= 28
+	PA29	Pin	= 29
+	PA30	Pin	= 30	// peripherals: TCC1 channel 0
+	PA31	Pin	= 31	// peripherals: TCC1 channel 1
+	PB00	Pin	= 32
+	PB01	Pin	= 33
+	PB02	Pin	= 34	// peripherals: sercomI2CM5 SDA
+	PB03	Pin	= 35	// peripherals: sercomI2CM5 SCL
+	PB04	Pin	= 36
+	PB05	Pin	= 37
+	PB06	Pin	= 38
+	PB07	Pin	= 39
+	PB08	Pin	= 40	// peripherals: sercomI2CM4 SDA
+	PB09	Pin	= 41	// peripherals: sercomI2CM4 SCL
+	PB10	Pin	= 42	// peripherals: TCC0 channel 0
+	PB11	Pin	= 43	// peripherals: TCC0 channel 1
+	PB12	Pin	= 44	// peripherals: TCC0 channel 2, sercomI2CM4 SDA
+	PB13	Pin	= 45	// peripherals: TCC0 channel 3, sercomI2CM4 SCL
+	PB14	Pin	= 46
+	PB15	Pin	= 47
+	PB16	Pin	= 48	// peripherals: TCC0 channel 0, sercomI2CM5 SDA
+	PB17	Pin	= 49	// peripherals: TCC0 channel 1, sercomI2CM5 SCL
+	PB18	Pin	= 50
+	PB19	Pin	= 51
+	PB20	Pin	= 52
+	PB21	Pin	= 53
+	PB22	Pin	= 54
+	PB23	Pin	= 55
+	PB24	Pin	= 56
+	PB25	Pin	= 57
+	PB26	Pin	= 58
+	PB27	Pin	= 59
+	PB28	Pin	= 60
+	PB29	Pin	= 61
+	PB30	Pin	= 62	// peripherals: TCC0 channel 0, TCC1 channel 2, sercomI2CM5 SDA
+	PB31	Pin	= 63	// peripherals: TCC0 channel 1, TCC1 channel 3, sercomI2CM5 SCL
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const (
+	I2SModeSource	I2SMode	= iota
+	I2SModeReceiver
+	I2SModePDM
+	I2SModeSourceReceiver
+)
+```
+
+
+
+```go
+const (
+	I2StandardPhilips	I2SStandard	= iota
+	I2SStandardMSB
+	I2SStandardLSB
+)
+```
+
+
+
+```go
+const (
+	I2SClockSourceInternal	I2SClockSource	= iota
+	I2SClockSourceExternal
+)
+```
+
+
+
+```go
+const (
+	I2SDataFormatDefault	I2SDataFormat	= 0
+	I2SDataFormat8bit			= 8
+	I2SDataFormat16bit			= 16
+	I2SDataFormat24bit			= 24
+	I2SDataFormat32bit			= 32
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinAnalog	PinMode	= 1
+	PinSERCOM	PinMode	= 2
+	PinSERCOMAlt	PinMode	= 3
+	PinTimer	PinMode	= 4
+	PinTimerAlt	PinMode	= 5
+	PinCom		PinMode	= 6
+	//PinAC_CLK        PinMode = 7
+	PinDigital		PinMode	= 8
+	PinInput		PinMode	= 9
+	PinInputPullup		PinMode	= 10
+	PinOutput		PinMode	= 11
+	PinTCC			PinMode	= PinTimer
+	PinTCCAlt		PinMode	= PinTimerAlt
+	PinInputPulldown	PinMode	= 12
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
+	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
+	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (16s)
+	WatchdogMaxTimeout = (16384 * 1000) / 1024
+)
+```
+
+
+
+```go
+const (
+	// these are SAMD21 specific.
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Pos	= 0
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Mask	= 0x3FFF
+
+	usb_DEVICE_PCKSIZE_SIZE_Pos	= 28
+	usb_DEVICE_PCKSIZE_SIZE_Mask	= 0x7
+
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Pos	= 14
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Mask	= 0x3FFF
+
+	NumberOfUSBEndpoints	= 8
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var UART1 = &sercomUSART5
+```
+
+UART on the Arduino MKR WiFi 1010.
+
+
+```go
+var (
+	I2C0 = sercomI2CM2
+)
+```
+
+I2C on the Arduino MKR WiFi 1010.
+
+
+```go
+var (
+	SPI0	= sercomSPIM1
+
+	SPI1		= sercomSPIM4
+	NINA_SPI	= SPI1
+)
+```
+
+SPI on the Arduino MKR WiFi 1010.
+
+
+```go
+var (
+	DefaultUART = UART1
+)
+```
+
+
+
+```go
+var (
+	ErrInvalidSampleFrequency = errors.New("i2s: invalid sample frequency")
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var I2S0 = I2S{Bus: sam.I2S}
+```
+
+
+
+```go
+var (
+	TCC0	= (*TCC)(sam.TCC0)
+	TCC1	= (*TCC)(sam.TCC1)
+	TCC2	= (*TCC)(sam.TCC2)
+)
+```
+
+The SAM D21 has three TCC peripherals, which have PWM as one feature.
+
+
+```go
+var (
+	DAC0 = DAC{}
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the SAMD21.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+Return the current CPU frequency in hertz.
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) and 16 bytes (128 bits) are common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig)
+```
+
+Configure configures a ADC pin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type DAC
+
+```go
+type DAC struct {
+}
+```
+
+DAC on the SAMD21.
+
+
+
+### func (DAC) Configure
+
+```go
+func (dac DAC) Configure(config DACConfig)
+```
+
+Configure the DAC.
+output pin must already be configured.
+
+
+### func (DAC) Set
+
+```go
+func (dac DAC) Set(value uint16) error
+```
+
+Set writes a single 16-bit value to the DAC.
+Since the ATSAMD21 only has a 10-bit DAC, the passed-in value will be scaled down.
+
+
+
+
+## type DACConfig
+
+```go
+type DACConfig struct {
+}
+```
+
+DACConfig placeholder for future expansion.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*sam.SERCOM_I2CM_Type
+	SERCOM	uint8
+}
+```
+
+I2C on the SAMD21.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteByte
+
+```go
+func (i2c *I2C) WriteByte(data byte) error
+```
+
+WriteByte writes a single byte to the I2C bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type I2S
+
+```go
+type I2S struct {
+	Bus		*sam.I2S_Type
+	Frequency	uint32
+	DataFormat	I2SDataFormat
+}
+```
+
+I2S
+
+
+
+### func (*I2S) Configure
+
+```go
+func (i2s *I2S) Configure(config I2SConfig) error
+```
+
+Configure is used to configure the I2S interface. You must call this
+before you can use the I2S bus.
+
+
+### func (*I2S) Enable
+
+```go
+func (i2s *I2S) Enable(enabled bool)
+```
+
+Enabled is used to enable or disable the I2S bus.
+
+
+### func (*I2S) ReadMono
+
+```go
+func (i2s *I2S) ReadMono(p []uint16) (n int, err error)
+```
+
+Read mono data from the I2S bus into the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) ReadStereo
+
+```go
+func (i2s *I2S) ReadStereo(p []uint32) (n int, err error)
+```
+
+Read stereo data from the I2S bus into the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) SetSampleFrequency
+
+```go
+func (i2s *I2S) SetSampleFrequency(freq uint32) error
+```
+
+SetSampleFrequency is used to set the sample frequency for the I2S bus.
+
+
+### func (*I2S) WriteMono
+
+```go
+func (i2s *I2S) WriteMono(p []uint16) (n int, err error)
+```
+
+Write mono data to the I2S bus from the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) WriteStereo
+
+```go
+func (i2s *I2S) WriteStereo(p []uint32) (n int, err error)
+```
+
+Write stereo data to the I2S bus from the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+
+
+## type I2SClockSource
+
+```go
+type I2SClockSource uint8
+```
+
+
+
+
+
+
+## type I2SConfig
+
+```go
+type I2SConfig struct {
+	// clock
+	SCK	Pin
+	// word select
+	WS	Pin
+	// data out
+	SDO	Pin
+	// data in
+	SDI		Pin
+	Mode		I2SMode
+	Standard	I2SStandard
+	ClockSource	I2SClockSource
+	DataFormat	I2SDataFormat
+	AudioFrequency	uint32
+	MainClockOutput	bool
+	Stereo		bool
+}
+```
+
+All fields are optional and may not be required or used on a particular platform.
+
+
+
+
+
+## type I2SDataFormat
+
+```go
+type I2SDataFormat uint8
+```
+
+
+
+
+
+
+## type I2SMode
+
+```go
+type I2SMode uint8
+```
+
+
+
+
+
+
+## type I2SStandard
+
+```go
+type I2SStandard uint8
+```
+
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when configured as an input or as
+an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*sam.SERCOM_SPI_Type
+	SERCOM	uint8
+}
+```
+
+SPI
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type TCC
+
+```go
+type TCC sam.TCC_Type
+```
+
+TCC is one timer/counter peripheral, which consists of a counter and multiple
+output channels (that can be connected to actual pins). You can set the
+frequency using SetPeriod, but only for all the channels in this TCC
+peripheral at once.
+
+
+
+### func (*TCC) Channel
+
+```go
+func (tcc *TCC) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin. Note that one channel may be
+shared between multiple pins, and so will have the same duty cycle. If this
+is not desirable, look for a different TCC peripheral or consider using a
+different pin.
+
+
+### func (*TCC) Configure
+
+```go
+func (tcc *TCC) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this TCC.
+
+
+### func (*TCC) Counter
+
+```go
+func (tcc *TCC) Counter() uint32
+```
+
+Counter returns the current counter value of the timer in this TCC
+peripheral. It may be useful for debugging.
+
+
+### func (*TCC) Set
+
+```go
+func (tcc *TCC) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle, in other words the fraction of time the channel output is high (or low
+when inverted). For example, to set it to a 25% duty cycle, use:
+
+	tcc.Set(channel, tcc.Top() / 4)
+
+tcc.Set(channel, 0) will set the output to low and tcc.Set(channel,
+tcc.Top()) will set the output to high, assuming the output isn't inverted.
+
+
+### func (*TCC) SetInverting
+
+```go
+func (tcc *TCC) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TCC) SetPeriod
+
+```go
+func (tcc *TCC) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this TCC peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the TCC peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TCC) Top
+
+```go
+func (tcc *TCC) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to Set
+(see Set documentation for more information).
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*sam.SERCOM_USART_Type
+	SERCOM		uint8
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the SAMD21.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/arduino-nano.md b/content/docs/reference/microcontrollers/machine/arduino-nano.md
new file mode 100644
index 00000000..dd3f375f
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/arduino-nano.md
@@ -0,0 +1,1190 @@
+
+---
+title: arduino-nano
+---
+
+
+## Constants
+
+```go
+const (
+	D0	= PD0	// RX0
+	D1	= PD1	// TX1
+	D2	= PD2
+	D3	= PD3
+	D4	= PD4
+	D5	= PD5
+	D6	= PD6
+	D7	= PD7
+	D8	= PB0
+	D9	= PB1
+	D10	= PB2
+	D11	= PB3
+	D12	= PB4
+	D13	= PB5
+)
+```
+
+Digital pins.
+
+
+```go
+const LED Pin = D13
+```
+
+LED on the Arduino
+
+
+```go
+const (
+	ADC0	Pin	= PC0
+	ADC1	Pin	= PC1
+	ADC2	Pin	= PC2
+	ADC3	Pin	= PC3
+	ADC4	Pin	= PC4	// Used by TWI for SDA
+	ADC5	Pin	= PC5	// Used by TWI for SCL
+)
+```
+
+ADC on the Arduino
+
+
+```go
+const (
+	UART_TX_PIN	Pin	= PD1
+	UART_RX_PIN	Pin	= PD0
+)
+```
+
+UART pins
+
+
+```go
+const (
+	PB0	= portB + 0
+	PB1	= portB + 1	// peripherals: Timer1 channel A
+	PB2	= portB + 2	// peripherals: Timer1 channel B
+	PB3	= portB + 3	// peripherals: Timer2 channel A
+	PB4	= portB + 4
+	PB5	= portB + 5
+	PB6	= portB + 6
+	PB7	= portB + 7
+	PC0	= portC + 0
+	PC1	= portC + 1
+	PC2	= portC + 2
+	PC3	= portC + 3
+	PC4	= portC + 4	// peripherals: I2C0 SDA
+	PC5	= portC + 5	// peripherals: I2C0 SCL
+	PC6	= portC + 6
+	PC7	= portC + 7
+	PD0	= portD + 0
+	PD1	= portD + 1
+	PD2	= portD + 2
+	PD3	= portD + 3	// peripherals: Timer2 channel B
+	PD4	= portD + 4
+	PD5	= portD + 5	// peripherals: Timer0 channel B
+	PD6	= portD + 6	// peripherals: Timer0 channel A
+	PD7	= portD + 7
+)
+```
+
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinRising	PinChange	= 1 << iota
+	PinFalling
+	PinToggle	= PinRising | PinFalling
+)
+```
+
+
+
+```go
+const (
+	PinInput	PinMode	= iota
+	PinInputPullup
+	PinOutput
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var DefaultUART = UART0
+```
+
+Always use UART0 as the serial output.
+
+
+```go
+var (
+	// UART0 is the hardware serial port on the AVR.
+	UART0	= &_UART0
+	_UART0	= UART{
+		Buffer:	NewRingBuffer(),
+
+		dataReg:	avr.UDR0,
+		baudRegH:	avr.UBRR0H,
+		baudRegL:	avr.UBRR0L,
+		statusRegA:	avr.UCSR0A,
+		statusRegB:	avr.UCSR0B,
+		statusRegC:	avr.UCSR0C,
+	}
+)
+```
+
+UART
+
+
+```go
+var (
+	Timer0	= PWM{0}	// 8 bit timer for PD5 and PD6
+	Timer1	= PWM{1}	// 16 bit timer for PB1 and PB2
+	Timer2	= PWM{2}	// 8 bit timer for PB3 and PD3
+)
+```
+
+
+
+```go
+var I2C0 = &I2C{
+	srReg:	avr.TWSR,
+	brReg:	avr.TWBR,
+	crReg:	avr.TWCR,
+	drReg:	avr.TWDR,
+	srPS0:	avr.TWSR_TWPS0,
+	srPS1:	avr.TWSR_TWPS1,
+	crEN:	avr.TWCR_TWEN,
+	crINT:	avr.TWCR_TWINT,
+	crSTO:	avr.TWCR_TWSTO,
+	crEA:	avr.TWCR_TWEA,
+	crSTA:	avr.TWCR_TWSTA,
+}
+```
+
+I2C0 is the only I2C interface on most AVRs.
+
+
+```go
+var SPI0 = &SPI{
+	spcr:	avr.SPCR,
+	spdr:	avr.SPDR,
+	spsr:	avr.SPSR,
+
+	spcrR0:		avr.SPCR_SPR0,
+	spcrR1:		avr.SPCR_SPR1,
+	spcrCPHA:	avr.SPCR_CPHA,
+	spcrCPOL:	avr.SPCR_CPOL,
+	spcrDORD:	avr.SPCR_DORD,
+	spcrSPE:	avr.SPCR_SPE,
+	spcrMSTR:	avr.SPCR_MSTR,
+
+	spsrI2X:	avr.SPSR_SPI2X,
+	spsrSPIF:	avr.SPSR_SPIF,
+
+	sck:	PB5,
+	sdo:	PB3,
+	sdi:	PB4,
+	cs:	PB2,
+}
+```
+
+SPI configuration
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+Return the current CPU frequency in hertz.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(ADCConfig)
+```
+
+Configure configures a ADCPin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff. The AVR
+has an ADC of 10 bits precision so the lower 6 bits will be zero.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	srReg	*volatile.Register8
+	brReg	*volatile.Register8
+	crReg	*volatile.Register8
+	drReg	*volatile.Register8
+
+	srPS0	byte
+	srPS1	byte
+	crEN	byte
+	crINT	byte
+	crSTO	byte
+	crEA	byte
+	crSTA	byte
+}
+```
+
+I2C on AVR.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency uint32
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWM
+
+```go
+type PWM struct {
+	num uint8
+}
+```
+
+PWM is one PWM peripheral, which consists of a counter and two output
+channels (that can be connected to two fixed pins). You can set the frequency
+using SetPeriod, but only for all the channels in this PWM peripheral at
+once.
+
+
+
+### func (PWM) Channel
+
+```go
+func (pwm PWM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (PWM) Configure
+
+```go
+func (pwm PWM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+
+For the two 8 bit timers, there is only a limited number of periods
+available, namely the CPU frequency divided by 256 and again divided by 1, 8,
+64, 256, or 1024. For a MCU running at 16MHz, this would be a period of 16µs,
+128µs, 1024µs, 4096µs, or 16384µs.
+
+
+### func (PWM) Counter
+
+```go
+func (pwm PWM) Counter() uint32
+```
+
+Counter returns the current counter value of the timer in this PWM
+peripheral. It may be useful for debugging.
+
+
+### func (PWM) Period
+
+```go
+func (pwm PWM) Period() uint64
+```
+
+Period returns the used PWM period in nanoseconds. It might deviate slightly
+from the configured period due to rounding.
+
+
+### func (PWM) Set
+
+```go
+func (pwm PWM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle, in other words the fraction of time the channel output is high (or low
+when inverted). For example, to set it to a 25% duty cycle, use:
+
+	pwm.Set(channel, pwm.Top() / 4)
+
+pwm.Set(channel, 0) will set the output to low and pwm.Set(channel,
+pwm.Top()) will set the output to high, assuming the output isn't inverted.
+
+
+### func (PWM) SetInverting
+
+```go
+func (pwm PWM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+Note: the invert state may not be applied on the AVR until the next call to
+ch.Set().
+
+
+### func (PWM) SetPeriod
+
+```go
+func (pwm PWM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (PWM) Top
+
+```go
+func (pwm PWM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to Set
+(see Set documentation for more information).
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure sets the pin to input or output.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*volatile.Register8, uint8)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+Warning: there are no separate pin set/clear registers on the AVR. The
+returned mask is only valid as long as no other pin in the same port has been
+changed.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*volatile.Register8, uint8)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+Warning: there are no separate pin set/clear registers on the AVR. The
+returned mask is only valid as long as no other pin in the same port has been
+changed.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set changes the value of the GPIO pin. The pin must be configured as output.
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (pin Pin) SetInterrupt(pinChange PinChange, callback func(Pin)) (err error)
+```
+
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+Pin Change Interrupts
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	// The registers for the SPIx port set by the chip
+	spcr	*volatile.Register8
+	spdr	*volatile.Register8
+	spsr	*volatile.Register8
+
+	spcrR0		byte
+	spcrR1		byte
+	spcrCPHA	byte
+	spcrCPOL	byte
+	spcrDORD	byte
+	spcrSPE		byte
+	spcrMSTR	byte
+
+	spsrI2X		byte
+	spsrSPIF	byte
+
+	// The io pins for the SPIx port set by the chip
+	sck	Pin
+	sdi	Pin
+	sdo	Pin
+	cs	Pin
+}
+```
+
+SPI is for the Serial Peripheral Interface
+Data is taken from http://ww1.microchip.com/downloads/en/DeviceDoc/ATmega48A-PA-88A-PA-168A-PA-328-P-DS-DS40002061A.pdf page 169 and following
+
+
+
+### func (*SPI) Configure
+
+```go
+func (s *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (s *SPI) Transfer(b byte) (byte, error)
+```
+
+Transfer writes the byte into the register and returns the read content
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer	*RingBuffer
+
+	dataReg		*volatile.Register8
+	baudRegH	*volatile.Register8
+	baudRegL	*volatile.Register8
+
+	statusRegA	*volatile.Register8
+	statusRegB	*volatile.Register8
+	statusRegC	*volatile.Register8
+}
+```
+
+UART on the AVR.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART on the AVR. Defaults to 9600 baud on Arduino.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/arduino-nano33.md b/content/docs/reference/microcontrollers/machine/arduino-nano33.md
new file mode 100644
index 00000000..4f3fb484
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/arduino-nano33.md
@@ -0,0 +1,1798 @@
+
+---
+title: arduino-nano33
+---
+
+
+## Constants
+
+```go
+const (
+	RX0	Pin	= PB23	// UART2 RX
+	TX1	Pin	= PB22	// UART2 TX
+
+	D2	Pin	= PB10	// PWM available
+	D3	Pin	= PB11	// PWM available
+	D4	Pin	= PA07
+	D5	Pin	= PA05	// PWM available
+	D6	Pin	= PA04	// PWM available
+	D7	Pin	= PA06
+
+	D8	Pin	= PA18
+	D9	Pin	= PA20	// PWM available
+	D10	Pin	= PA21	// PWM available
+	D11	Pin	= PA16	// PWM available
+	D12	Pin	= PA19	// PWM available
+
+	D13	Pin	= PA17
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A0	Pin	= PA02	// ADC/AIN[0]
+	A1	Pin	= PB02	// ADC/AIN[10]
+	A2	Pin	= PA11	// ADC/AIN[19]
+	A3	Pin	= PA10	// ADC/AIN[18],
+	A4	Pin	= PB08	// ADC/AIN[2], SCL:  SERCOM2/PAD[1]
+	A5	Pin	= PB09	// ADC/AIN[3], SDA:  SERCOM2/PAD[1]
+	A6	Pin	= PA09	// ADC/AIN[17]
+	A7	Pin	= PB03	// ADC/AIN[11]
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	LED = D13
+)
+```
+
+
+
+```go
+const (
+	USBCDC_DM_PIN	Pin	= PA24
+	USBCDC_DP_PIN	Pin	= PA25
+)
+```
+
+USBCDC pins
+
+
+```go
+const (
+	UART_TX_PIN	Pin	= PA22
+	UART_RX_PIN	Pin	= PA23
+)
+```
+
+UART1 pins
+
+
+```go
+const (
+	SDA_PIN	Pin	= A4	// SDA: SERCOM4/PAD[1]
+	SCL_PIN	Pin	= A5	// SCL: SERCOM4/PAD[1]
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	Pin	= D13	// SCK: SERCOM1/PAD[1]
+	SPI0_SDO_PIN	Pin	= D11	// SDO: SERCOM1/PAD[0]
+	SPI0_SDI_PIN	Pin	= D12	// SDI: SERCOM1/PAD[3]
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	NINA_SDO	Pin	= PA12
+	NINA_SDI	Pin	= PA13
+	NINA_CS		Pin	= PA14
+	NINA_SCK	Pin	= PA15
+	NINA_GPIO0	Pin	= PA27
+	NINA_RESETN	Pin	= PA08
+	NINA_ACK	Pin	= PA28
+	NINA_TX		Pin	= PA12
+	NINA_RX		Pin	= PA13
+	NINA_RTS	Pin	= PA14
+	NINA_CTS	Pin	= PA15
+)
+```
+
+NINA-W102 Pins
+
+
+```go
+const (
+	NINA_BAUDRATE		= 912600
+	NINA_RESET_INVERTED	= true
+	NINA_SOFT_FLOWCONTROL	= false
+)
+```
+
+NINA-W102 settings
+
+
+```go
+const (
+	I2S_SCK_PIN	Pin	= PA10
+	I2S_SDO_PIN	Pin	= PA08
+	I2S_SDI_PIN		= NoPin
+	I2S_WS_PIN		= NoPin	// TODO: figure out what this is on Arduino Nano 33.
+)
+```
+
+I2S pins
+
+
+```go
+const (
+	PA00	Pin	= 0	// peripherals: TCC2 channel 0, sercomI2CM1 SDA
+	PA01	Pin	= 1	// peripherals: TCC2 channel 1, sercomI2CM1 SCL
+	PA02	Pin	= 2
+	PA03	Pin	= 3
+	PA04	Pin	= 4	// peripherals: TCC0 channel 0
+	PA05	Pin	= 5	// peripherals: TCC0 channel 1
+	PA06	Pin	= 6	// peripherals: TCC1 channel 0
+	PA07	Pin	= 7	// peripherals: TCC1 channel 1
+	PA08	Pin	= 8	// peripherals: TCC0 channel 0, TCC1 channel 2, sercomI2CM0 SDA, sercomI2CM2 SDA
+	PA09	Pin	= 9	// peripherals: TCC0 channel 1, TCC1 channel 3, sercomI2CM0 SCL, sercomI2CM2 SCL
+	PA10	Pin	= 10	// peripherals: TCC1 channel 0, TCC0 channel 2
+	PA11	Pin	= 11	// peripherals: TCC1 channel 1, TCC0 channel 3
+	PA12	Pin	= 12	// peripherals: TCC2 channel 0, TCC0 channel 2, sercomI2CM2 SDA, sercomI2CM4 SDA
+	PA13	Pin	= 13	// peripherals: TCC2 channel 1, TCC0 channel 3, sercomI2CM2 SCL, sercomI2CM4 SCL
+	PA14	Pin	= 14	// peripherals: TCC0 channel 0
+	PA15	Pin	= 15	// peripherals: TCC0 channel 1
+	PA16	Pin	= 16	// peripherals: TCC2 channel 0, TCC0 channel 2, sercomI2CM1 SDA, sercomI2CM3 SDA
+	PA17	Pin	= 17	// peripherals: TCC2 channel 1, TCC0 channel 3, sercomI2CM1 SCL, sercomI2CM3 SCL
+	PA18	Pin	= 18	// peripherals: TCC0 channel 2
+	PA19	Pin	= 19	// peripherals: TCC0 channel 3
+	PA20	Pin	= 20	// peripherals: TCC0 channel 2
+	PA21	Pin	= 21	// peripherals: TCC0 channel 3
+	PA22	Pin	= 22	// peripherals: TCC0 channel 0, sercomI2CM3 SDA, sercomI2CM5 SDA
+	PA23	Pin	= 23	// peripherals: TCC0 channel 1, sercomI2CM3 SCL, sercomI2CM5 SCL
+	PA24	Pin	= 24	// peripherals: TCC1 channel 2
+	PA25	Pin	= 25	// peripherals: TCC1 channel 3
+	PA26	Pin	= 26
+	PA27	Pin	= 27
+	PA28	Pin	= 28
+	PA29	Pin	= 29
+	PA30	Pin	= 30	// peripherals: TCC1 channel 0
+	PA31	Pin	= 31	// peripherals: TCC1 channel 1
+	PB00	Pin	= 32
+	PB01	Pin	= 33
+	PB02	Pin	= 34	// peripherals: sercomI2CM5 SDA
+	PB03	Pin	= 35	// peripherals: sercomI2CM5 SCL
+	PB04	Pin	= 36
+	PB05	Pin	= 37
+	PB06	Pin	= 38
+	PB07	Pin	= 39
+	PB08	Pin	= 40	// peripherals: sercomI2CM4 SDA
+	PB09	Pin	= 41	// peripherals: sercomI2CM4 SCL
+	PB10	Pin	= 42	// peripherals: TCC0 channel 0
+	PB11	Pin	= 43	// peripherals: TCC0 channel 1
+	PB12	Pin	= 44	// peripherals: TCC0 channel 2, sercomI2CM4 SDA
+	PB13	Pin	= 45	// peripherals: TCC0 channel 3, sercomI2CM4 SCL
+	PB14	Pin	= 46
+	PB15	Pin	= 47
+	PB16	Pin	= 48	// peripherals: TCC0 channel 0, sercomI2CM5 SDA
+	PB17	Pin	= 49	// peripherals: TCC0 channel 1, sercomI2CM5 SCL
+	PB18	Pin	= 50
+	PB19	Pin	= 51
+	PB20	Pin	= 52
+	PB21	Pin	= 53
+	PB22	Pin	= 54
+	PB23	Pin	= 55
+	PB24	Pin	= 56
+	PB25	Pin	= 57
+	PB26	Pin	= 58
+	PB27	Pin	= 59
+	PB28	Pin	= 60
+	PB29	Pin	= 61
+	PB30	Pin	= 62	// peripherals: TCC0 channel 0, TCC1 channel 2, sercomI2CM5 SDA
+	PB31	Pin	= 63	// peripherals: TCC0 channel 1, TCC1 channel 3, sercomI2CM5 SCL
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const (
+	I2SModeSource	I2SMode	= iota
+	I2SModeReceiver
+	I2SModePDM
+	I2SModeSourceReceiver
+)
+```
+
+
+
+```go
+const (
+	I2StandardPhilips	I2SStandard	= iota
+	I2SStandardMSB
+	I2SStandardLSB
+)
+```
+
+
+
+```go
+const (
+	I2SClockSourceInternal	I2SClockSource	= iota
+	I2SClockSourceExternal
+)
+```
+
+
+
+```go
+const (
+	I2SDataFormatDefault	I2SDataFormat	= 0
+	I2SDataFormat8bit			= 8
+	I2SDataFormat16bit			= 16
+	I2SDataFormat24bit			= 24
+	I2SDataFormat32bit			= 32
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinAnalog	PinMode	= 1
+	PinSERCOM	PinMode	= 2
+	PinSERCOMAlt	PinMode	= 3
+	PinTimer	PinMode	= 4
+	PinTimerAlt	PinMode	= 5
+	PinCom		PinMode	= 6
+	//PinAC_CLK        PinMode = 7
+	PinDigital		PinMode	= 8
+	PinInput		PinMode	= 9
+	PinInputPullup		PinMode	= 10
+	PinOutput		PinMode	= 11
+	PinTCC			PinMode	= PinTimer
+	PinTCCAlt		PinMode	= PinTimerAlt
+	PinInputPulldown	PinMode	= 12
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
+	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
+	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (16s)
+	WatchdogMaxTimeout = (16384 * 1000) / 1024
+)
+```
+
+
+
+```go
+const (
+	// these are SAMD21 specific.
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Pos	= 0
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Mask	= 0x3FFF
+
+	usb_DEVICE_PCKSIZE_SIZE_Pos	= 28
+	usb_DEVICE_PCKSIZE_SIZE_Mask	= 0x7
+
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Pos	= 14
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Mask	= 0x3FFF
+
+	NumberOfUSBEndpoints	= 8
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var UART1 = &sercomUSART3
+```
+
+UART1 on the Arduino Nano 33 connects to the onboard NINA-W102 WiFi chip.
+
+
+```go
+var UART2 = &sercomUSART5
+```
+
+UART2 on the Arduino Nano 33 connects to the normal TX/RX pins.
+
+
+```go
+var UART_NINA = &sercomUSART2
+```
+
+UART_NINA on the Arduino Nano 33 connects to the NINA HCI.
+
+
+```go
+var (
+	I2C0 = sercomI2CM4
+)
+```
+
+I2C on the Arduino Nano 33.
+
+
+```go
+var SPI0 = sercomSPIM1
+```
+
+SPI on the Arduino Nano 33.
+
+
+```go
+var (
+	SPI1		= sercomSPIM2
+	NINA_SPI	= SPI1
+)
+```
+
+SPI1 is connected to the NINA-W102 chip on the Arduino Nano 33.
+
+
+```go
+var (
+	ErrInvalidSampleFrequency = errors.New("i2s: invalid sample frequency")
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var I2S0 = I2S{Bus: sam.I2S}
+```
+
+
+
+```go
+var (
+	TCC0	= (*TCC)(sam.TCC0)
+	TCC1	= (*TCC)(sam.TCC1)
+	TCC2	= (*TCC)(sam.TCC2)
+)
+```
+
+The SAM D21 has three TCC peripherals, which have PWM as one feature.
+
+
+```go
+var (
+	DAC0 = DAC{}
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the SAMD21.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+Return the current CPU frequency in hertz.
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) and 16 bytes (128 bits) are common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig)
+```
+
+Configure configures a ADC pin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type DAC
+
+```go
+type DAC struct {
+}
+```
+
+DAC on the SAMD21.
+
+
+
+### func (DAC) Configure
+
+```go
+func (dac DAC) Configure(config DACConfig)
+```
+
+Configure the DAC.
+output pin must already be configured.
+
+
+### func (DAC) Set
+
+```go
+func (dac DAC) Set(value uint16) error
+```
+
+Set writes a single 16-bit value to the DAC.
+Since the ATSAMD21 only has a 10-bit DAC, the passed-in value will be scaled down.
+
+
+
+
+## type DACConfig
+
+```go
+type DACConfig struct {
+}
+```
+
+DACConfig placeholder for future expansion.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*sam.SERCOM_I2CM_Type
+	SERCOM	uint8
+}
+```
+
+I2C on the SAMD21.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteByte
+
+```go
+func (i2c *I2C) WriteByte(data byte) error
+```
+
+WriteByte writes a single byte to the I2C bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type I2S
+
+```go
+type I2S struct {
+	Bus		*sam.I2S_Type
+	Frequency	uint32
+	DataFormat	I2SDataFormat
+}
+```
+
+I2S
+
+
+
+### func (*I2S) Configure
+
+```go
+func (i2s *I2S) Configure(config I2SConfig) error
+```
+
+Configure is used to configure the I2S interface. You must call this
+before you can use the I2S bus.
+
+
+### func (*I2S) Enable
+
+```go
+func (i2s *I2S) Enable(enabled bool)
+```
+
+Enabled is used to enable or disable the I2S bus.
+
+
+### func (*I2S) ReadMono
+
+```go
+func (i2s *I2S) ReadMono(p []uint16) (n int, err error)
+```
+
+Read mono data from the I2S bus into the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) ReadStereo
+
+```go
+func (i2s *I2S) ReadStereo(p []uint32) (n int, err error)
+```
+
+Read stereo data from the I2S bus into the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) SetSampleFrequency
+
+```go
+func (i2s *I2S) SetSampleFrequency(freq uint32) error
+```
+
+SetSampleFrequency is used to set the sample frequency for the I2S bus.
+
+
+### func (*I2S) WriteMono
+
+```go
+func (i2s *I2S) WriteMono(p []uint16) (n int, err error)
+```
+
+Write mono data to the I2S bus from the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) WriteStereo
+
+```go
+func (i2s *I2S) WriteStereo(p []uint32) (n int, err error)
+```
+
+Write stereo data to the I2S bus from the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+
+
+## type I2SClockSource
+
+```go
+type I2SClockSource uint8
+```
+
+
+
+
+
+
+## type I2SConfig
+
+```go
+type I2SConfig struct {
+	// clock
+	SCK	Pin
+	// word select
+	WS	Pin
+	// data out
+	SDO	Pin
+	// data in
+	SDI		Pin
+	Mode		I2SMode
+	Standard	I2SStandard
+	ClockSource	I2SClockSource
+	DataFormat	I2SDataFormat
+	AudioFrequency	uint32
+	MainClockOutput	bool
+	Stereo		bool
+}
+```
+
+All fields are optional and may not be required or used on a particular platform.
+
+
+
+
+
+## type I2SDataFormat
+
+```go
+type I2SDataFormat uint8
+```
+
+
+
+
+
+
+## type I2SMode
+
+```go
+type I2SMode uint8
+```
+
+
+
+
+
+
+## type I2SStandard
+
+```go
+type I2SStandard uint8
+```
+
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when configured as an input or as
+an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*sam.SERCOM_SPI_Type
+	SERCOM	uint8
+}
+```
+
+SPI
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type TCC
+
+```go
+type TCC sam.TCC_Type
+```
+
+TCC is one timer/counter peripheral, which consists of a counter and multiple
+output channels (that can be connected to actual pins). You can set the
+frequency using SetPeriod, but only for all the channels in this TCC
+peripheral at once.
+
+
+
+### func (*TCC) Channel
+
+```go
+func (tcc *TCC) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin. Note that one channel may be
+shared between multiple pins, and so will have the same duty cycle. If this
+is not desirable, look for a different TCC peripheral or consider using a
+different pin.
+
+
+### func (*TCC) Configure
+
+```go
+func (tcc *TCC) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this TCC.
+
+
+### func (*TCC) Counter
+
+```go
+func (tcc *TCC) Counter() uint32
+```
+
+Counter returns the current counter value of the timer in this TCC
+peripheral. It may be useful for debugging.
+
+
+### func (*TCC) Set
+
+```go
+func (tcc *TCC) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle, in other words the fraction of time the channel output is high (or low
+when inverted). For example, to set it to a 25% duty cycle, use:
+
+	tcc.Set(channel, tcc.Top() / 4)
+
+tcc.Set(channel, 0) will set the output to low and tcc.Set(channel,
+tcc.Top()) will set the output to high, assuming the output isn't inverted.
+
+
+### func (*TCC) SetInverting
+
+```go
+func (tcc *TCC) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TCC) SetPeriod
+
+```go
+func (tcc *TCC) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this TCC peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the TCC peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TCC) Top
+
+```go
+func (tcc *TCC) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to Set
+(see Set documentation for more information).
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*sam.SERCOM_USART_Type
+	SERCOM		uint8
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the SAMD21.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/arduino-zero.md b/content/docs/reference/microcontrollers/machine/arduino-zero.md
new file mode 100644
index 00000000..fc2f414b
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/arduino-zero.md
@@ -0,0 +1,1750 @@
+
+---
+title: arduino-zero
+---
+
+
+## Constants
+
+```go
+const (
+	D0	= PA11	// RX
+	D1	= PA10	// TX
+	D2	= PA14
+	D3	= PA09	// PWM available
+	D4	= PA08	// PWM available
+	D5	= PA15	// PWM available
+	D6	= PA20	// PWM available
+	D7	= PA21
+)
+```
+
+GPIO Pins - Digital Low
+
+
+```go
+const (
+	D8	= PA06	// PWM available
+	D9	= PA07	// PWM available
+	D10	= PA18	// PWM available
+	D11	= PA16	// PWM available
+	D12	= PA19	// PWM available
+	D13	= PA17	// PWM available
+)
+```
+
+GPIO Pins - Digital High
+
+
+```go
+const (
+	AREF	Pin	= PA03
+	ADC0	Pin	= PA02
+	ADC1	Pin	= PB08
+	ADC2	Pin	= PB09
+	ADC3	Pin	= PA04
+	ADC4	Pin	= PA05
+	ADC5	Pin	= PB02
+)
+```
+
+ADC pins
+
+
+```go
+const (
+	LED		= LED1
+	LED1	Pin	= D13
+	LED2	Pin	= PA27	// TX LED
+	LED3	Pin	= PB03	// RX LED
+)
+```
+
+LEDs on the Arduino Zero
+
+
+```go
+const (
+	SPI0_SDO_PIN	Pin	= PA16	// MOSI: SERCOM1/PAD[0]
+	SPI0_SDI_PIN	Pin	= PA19	// MISO: SERCOM1/PAD[2]
+	SPI0_SCK_PIN	Pin	= PA17	// SCK:  SERCOM1/PAD[3]
+)
+```
+
+SPI pins - EDBG connected
+
+
+```go
+const (
+	SPI1_SDO_PIN	Pin	= PB10	// MOSI: SERCOM4/PAD[2] - Pin 4
+	SPI1_SDI_PIN	Pin	= PA12	// MISO: SERCOM4/PAD[0] - Pin 1
+	SPI1_SCK_PIN	Pin	= PB11	// SCK:  SERCOM4/PAD[3] - Pin 3
+)
+```
+
+SPI pins (Legacy ICSP)
+
+
+```go
+const (
+	SDA_PIN	Pin	= PA22	// SDA: SERCOM3/PAD[0] - Pin 20
+	SCL_PIN	Pin	= PA23	// SCL: SERCOM3/PAD[1] - Pin 21
+)
+```
+
+I2C pins - EDBG connected
+
+
+```go
+const (
+	I2S_SCK_PIN	Pin	= PA10
+	I2S_SDO_PIN	Pin	= PA07
+	I2S_SDI_PIN		= NoPin
+	I2S_WS_PIN	Pin	= PA11
+)
+```
+
+I2S pins - might not be exposed
+
+
+```go
+const (
+	UART_RX_PIN	Pin	= D0
+	UART_TX_PIN	Pin	= D1
+)
+```
+
+UART0 pins - EDBG connected
+
+
+```go
+const (
+	USBCDC_DM_PIN	Pin	= PA24
+	USBCDC_DP_PIN	Pin	= PA25
+)
+```
+
+'native' USB port pins
+
+
+```go
+const (
+	XIN32	Pin	= PA00
+	XOUT32	Pin	= PA01
+)
+```
+
+32.768 KHz Crystal
+
+
+```go
+const (
+	PA00	Pin	= 0	// peripherals: TCC2 channel 0, sercomI2CM1 SDA
+	PA01	Pin	= 1	// peripherals: TCC2 channel 1, sercomI2CM1 SCL
+	PA02	Pin	= 2
+	PA03	Pin	= 3
+	PA04	Pin	= 4	// peripherals: TCC0 channel 0
+	PA05	Pin	= 5	// peripherals: TCC0 channel 1
+	PA06	Pin	= 6	// peripherals: TCC1 channel 0
+	PA07	Pin	= 7	// peripherals: TCC1 channel 1
+	PA08	Pin	= 8	// peripherals: TCC0 channel 0, TCC1 channel 2, sercomI2CM0 SDA, sercomI2CM2 SDA
+	PA09	Pin	= 9	// peripherals: TCC0 channel 1, TCC1 channel 3, sercomI2CM0 SCL, sercomI2CM2 SCL
+	PA10	Pin	= 10	// peripherals: TCC1 channel 0, TCC0 channel 2
+	PA11	Pin	= 11	// peripherals: TCC1 channel 1, TCC0 channel 3
+	PA12	Pin	= 12	// peripherals: TCC2 channel 0, TCC0 channel 2, sercomI2CM2 SDA, sercomI2CM4 SDA
+	PA13	Pin	= 13	// peripherals: TCC2 channel 1, TCC0 channel 3, sercomI2CM2 SCL, sercomI2CM4 SCL
+	PA14	Pin	= 14	// peripherals: TCC0 channel 0
+	PA15	Pin	= 15	// peripherals: TCC0 channel 1
+	PA16	Pin	= 16	// peripherals: TCC2 channel 0, TCC0 channel 2, sercomI2CM1 SDA, sercomI2CM3 SDA
+	PA17	Pin	= 17	// peripherals: TCC2 channel 1, TCC0 channel 3, sercomI2CM1 SCL, sercomI2CM3 SCL
+	PA18	Pin	= 18	// peripherals: TCC0 channel 2
+	PA19	Pin	= 19	// peripherals: TCC0 channel 3
+	PA20	Pin	= 20	// peripherals: TCC0 channel 2
+	PA21	Pin	= 21	// peripherals: TCC0 channel 3
+	PA22	Pin	= 22	// peripherals: TCC0 channel 0, sercomI2CM3 SDA, sercomI2CM5 SDA
+	PA23	Pin	= 23	// peripherals: TCC0 channel 1, sercomI2CM3 SCL, sercomI2CM5 SCL
+	PA24	Pin	= 24	// peripherals: TCC1 channel 2
+	PA25	Pin	= 25	// peripherals: TCC1 channel 3
+	PA26	Pin	= 26
+	PA27	Pin	= 27
+	PA28	Pin	= 28
+	PA29	Pin	= 29
+	PA30	Pin	= 30	// peripherals: TCC1 channel 0
+	PA31	Pin	= 31	// peripherals: TCC1 channel 1
+	PB00	Pin	= 32
+	PB01	Pin	= 33
+	PB02	Pin	= 34	// peripherals: sercomI2CM5 SDA
+	PB03	Pin	= 35	// peripherals: sercomI2CM5 SCL
+	PB04	Pin	= 36
+	PB05	Pin	= 37
+	PB06	Pin	= 38
+	PB07	Pin	= 39
+	PB08	Pin	= 40	// peripherals: sercomI2CM4 SDA
+	PB09	Pin	= 41	// peripherals: sercomI2CM4 SCL
+	PB10	Pin	= 42	// peripherals: TCC0 channel 0
+	PB11	Pin	= 43	// peripherals: TCC0 channel 1
+	PB12	Pin	= 44	// peripherals: TCC0 channel 2, sercomI2CM4 SDA
+	PB13	Pin	= 45	// peripherals: TCC0 channel 3, sercomI2CM4 SCL
+	PB14	Pin	= 46
+	PB15	Pin	= 47
+	PB16	Pin	= 48	// peripherals: TCC0 channel 0, sercomI2CM5 SDA
+	PB17	Pin	= 49	// peripherals: TCC0 channel 1, sercomI2CM5 SCL
+	PB18	Pin	= 50
+	PB19	Pin	= 51
+	PB20	Pin	= 52
+	PB21	Pin	= 53
+	PB22	Pin	= 54
+	PB23	Pin	= 55
+	PB24	Pin	= 56
+	PB25	Pin	= 57
+	PB26	Pin	= 58
+	PB27	Pin	= 59
+	PB28	Pin	= 60
+	PB29	Pin	= 61
+	PB30	Pin	= 62	// peripherals: TCC0 channel 0, TCC1 channel 2, sercomI2CM5 SDA
+	PB31	Pin	= 63	// peripherals: TCC0 channel 1, TCC1 channel 3, sercomI2CM5 SCL
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const (
+	I2SModeSource	I2SMode	= iota
+	I2SModeReceiver
+	I2SModePDM
+	I2SModeSourceReceiver
+)
+```
+
+
+
+```go
+const (
+	I2StandardPhilips	I2SStandard	= iota
+	I2SStandardMSB
+	I2SStandardLSB
+)
+```
+
+
+
+```go
+const (
+	I2SClockSourceInternal	I2SClockSource	= iota
+	I2SClockSourceExternal
+)
+```
+
+
+
+```go
+const (
+	I2SDataFormatDefault	I2SDataFormat	= 0
+	I2SDataFormat8bit			= 8
+	I2SDataFormat16bit			= 16
+	I2SDataFormat24bit			= 24
+	I2SDataFormat32bit			= 32
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinAnalog	PinMode	= 1
+	PinSERCOM	PinMode	= 2
+	PinSERCOMAlt	PinMode	= 3
+	PinTimer	PinMode	= 4
+	PinTimerAlt	PinMode	= 5
+	PinCom		PinMode	= 6
+	//PinAC_CLK        PinMode = 7
+	PinDigital		PinMode	= 8
+	PinInput		PinMode	= 9
+	PinInputPullup		PinMode	= 10
+	PinOutput		PinMode	= 11
+	PinTCC			PinMode	= PinTimer
+	PinTCCAlt		PinMode	= PinTimerAlt
+	PinInputPulldown	PinMode	= 12
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
+	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
+	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (16s)
+	WatchdogMaxTimeout = (16384 * 1000) / 1024
+)
+```
+
+
+
+```go
+const (
+	// these are SAMD21 specific.
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Pos	= 0
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Mask	= 0x3FFF
+
+	usb_DEVICE_PCKSIZE_SIZE_Pos	= 28
+	usb_DEVICE_PCKSIZE_SIZE_Mask	= 0x7
+
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Pos	= 14
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Mask	= 0x3FFF
+
+	NumberOfUSBEndpoints	= 8
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	ErrInvalidSampleFrequency = errors.New("i2s: invalid sample frequency")
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var I2S0 = I2S{Bus: sam.I2S}
+```
+
+
+
+```go
+var (
+	TCC0	= (*TCC)(sam.TCC0)
+	TCC1	= (*TCC)(sam.TCC1)
+	TCC2	= (*TCC)(sam.TCC2)
+)
+```
+
+The SAM D21 has three TCC peripherals, which have PWM as one feature.
+
+
+```go
+var (
+	DAC0 = DAC{}
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the SAMD21.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+Return the current CPU frequency in hertz.
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) and 16 bytes (128 bits) are common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig)
+```
+
+Configure configures a ADC pin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type DAC
+
+```go
+type DAC struct {
+}
+```
+
+DAC on the SAMD21.
+
+
+
+### func (DAC) Configure
+
+```go
+func (dac DAC) Configure(config DACConfig)
+```
+
+Configure the DAC.
+output pin must already be configured.
+
+
+### func (DAC) Set
+
+```go
+func (dac DAC) Set(value uint16) error
+```
+
+Set writes a single 16-bit value to the DAC.
+Since the ATSAMD21 only has a 10-bit DAC, the passed-in value will be scaled down.
+
+
+
+
+## type DACConfig
+
+```go
+type DACConfig struct {
+}
+```
+
+DACConfig placeholder for future expansion.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*sam.SERCOM_I2CM_Type
+	SERCOM	uint8
+}
+```
+
+I2C on the SAMD21.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteByte
+
+```go
+func (i2c *I2C) WriteByte(data byte) error
+```
+
+WriteByte writes a single byte to the I2C bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type I2S
+
+```go
+type I2S struct {
+	Bus		*sam.I2S_Type
+	Frequency	uint32
+	DataFormat	I2SDataFormat
+}
+```
+
+I2S
+
+
+
+### func (*I2S) Configure
+
+```go
+func (i2s *I2S) Configure(config I2SConfig) error
+```
+
+Configure is used to configure the I2S interface. You must call this
+before you can use the I2S bus.
+
+
+### func (*I2S) Enable
+
+```go
+func (i2s *I2S) Enable(enabled bool)
+```
+
+Enabled is used to enable or disable the I2S bus.
+
+
+### func (*I2S) ReadMono
+
+```go
+func (i2s *I2S) ReadMono(p []uint16) (n int, err error)
+```
+
+Read mono data from the I2S bus into the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) ReadStereo
+
+```go
+func (i2s *I2S) ReadStereo(p []uint32) (n int, err error)
+```
+
+Read stereo data from the I2S bus into the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) SetSampleFrequency
+
+```go
+func (i2s *I2S) SetSampleFrequency(freq uint32) error
+```
+
+SetSampleFrequency is used to set the sample frequency for the I2S bus.
+
+
+### func (*I2S) WriteMono
+
+```go
+func (i2s *I2S) WriteMono(p []uint16) (n int, err error)
+```
+
+Write mono data to the I2S bus from the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) WriteStereo
+
+```go
+func (i2s *I2S) WriteStereo(p []uint32) (n int, err error)
+```
+
+Write stereo data to the I2S bus from the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+
+
+## type I2SClockSource
+
+```go
+type I2SClockSource uint8
+```
+
+
+
+
+
+
+## type I2SConfig
+
+```go
+type I2SConfig struct {
+	// clock
+	SCK	Pin
+	// word select
+	WS	Pin
+	// data out
+	SDO	Pin
+	// data in
+	SDI		Pin
+	Mode		I2SMode
+	Standard	I2SStandard
+	ClockSource	I2SClockSource
+	DataFormat	I2SDataFormat
+	AudioFrequency	uint32
+	MainClockOutput	bool
+	Stereo		bool
+}
+```
+
+All fields are optional and may not be required or used on a particular platform.
+
+
+
+
+
+## type I2SDataFormat
+
+```go
+type I2SDataFormat uint8
+```
+
+
+
+
+
+
+## type I2SMode
+
+```go
+type I2SMode uint8
+```
+
+
+
+
+
+
+## type I2SStandard
+
+```go
+type I2SStandard uint8
+```
+
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when configured as an input or as
+an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*sam.SERCOM_SPI_Type
+	SERCOM	uint8
+}
+```
+
+SPI
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type TCC
+
+```go
+type TCC sam.TCC_Type
+```
+
+TCC is one timer/counter peripheral, which consists of a counter and multiple
+output channels (that can be connected to actual pins). You can set the
+frequency using SetPeriod, but only for all the channels in this TCC
+peripheral at once.
+
+
+
+### func (*TCC) Channel
+
+```go
+func (tcc *TCC) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin. Note that one channel may be
+shared between multiple pins, and so will have the same duty cycle. If this
+is not desirable, look for a different TCC peripheral or consider using a
+different pin.
+
+
+### func (*TCC) Configure
+
+```go
+func (tcc *TCC) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this TCC.
+
+
+### func (*TCC) Counter
+
+```go
+func (tcc *TCC) Counter() uint32
+```
+
+Counter returns the current counter value of the timer in this TCC
+peripheral. It may be useful for debugging.
+
+
+### func (*TCC) Set
+
+```go
+func (tcc *TCC) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle, in other words the fraction of time the channel output is high (or low
+when inverted). For example, to set it to a 25% duty cycle, use:
+
+	tcc.Set(channel, tcc.Top() / 4)
+
+tcc.Set(channel, 0) will set the output to low and tcc.Set(channel,
+tcc.Top()) will set the output to high, assuming the output isn't inverted.
+
+
+### func (*TCC) SetInverting
+
+```go
+func (tcc *TCC) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TCC) SetPeriod
+
+```go
+func (tcc *TCC) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this TCC peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the TCC peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TCC) Top
+
+```go
+func (tcc *TCC) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to Set
+(see Set documentation for more information).
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*sam.SERCOM_USART_Type
+	SERCOM		uint8
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the SAMD21.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/arduino.md b/content/docs/reference/microcontrollers/machine/arduino.md
new file mode 100644
index 00000000..2cc26922
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/arduino.md
@@ -0,0 +1,1190 @@
+
+---
+title: arduino
+---
+
+
+## Constants
+
+```go
+const (
+	D0	= PD0	// RX
+	D1	= PD1	// TX
+	D2	= PD2
+	D3	= PD3
+	D4	= PD4
+	D5	= PD5
+	D6	= PD6
+	D7	= PD7
+	D8	= PB0
+	D9	= PB1
+	D10	= PB2
+	D11	= PB3
+	D12	= PB4
+	D13	= PB5
+)
+```
+
+Digital pins, marked as plain numbers on the board.
+
+
+```go
+const LED Pin = D13
+```
+
+LED on the Arduino
+
+
+```go
+const (
+	ADC0	Pin	= PC0
+	ADC1	Pin	= PC1
+	ADC2	Pin	= PC2
+	ADC3	Pin	= PC3
+	ADC4	Pin	= PC4	// Used by TWI for SDA
+	ADC5	Pin	= PC5	// Used by TWI for SCL
+)
+```
+
+ADC on the Arduino
+
+
+```go
+const (
+	UART_TX_PIN	Pin	= PD1
+	UART_RX_PIN	Pin	= PD0
+)
+```
+
+UART pins
+
+
+```go
+const (
+	PB0	= portB + 0
+	PB1	= portB + 1	// peripherals: Timer1 channel A
+	PB2	= portB + 2	// peripherals: Timer1 channel B
+	PB3	= portB + 3	// peripherals: Timer2 channel A
+	PB4	= portB + 4
+	PB5	= portB + 5
+	PB6	= portB + 6
+	PB7	= portB + 7
+	PC0	= portC + 0
+	PC1	= portC + 1
+	PC2	= portC + 2
+	PC3	= portC + 3
+	PC4	= portC + 4	// peripherals: I2C0 SDA
+	PC5	= portC + 5	// peripherals: I2C0 SCL
+	PC6	= portC + 6
+	PC7	= portC + 7
+	PD0	= portD + 0
+	PD1	= portD + 1
+	PD2	= portD + 2
+	PD3	= portD + 3	// peripherals: Timer2 channel B
+	PD4	= portD + 4
+	PD5	= portD + 5	// peripherals: Timer0 channel B
+	PD6	= portD + 6	// peripherals: Timer0 channel A
+	PD7	= portD + 7
+)
+```
+
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinRising	PinChange	= 1 << iota
+	PinFalling
+	PinToggle	= PinRising | PinFalling
+)
+```
+
+
+
+```go
+const (
+	PinInput	PinMode	= iota
+	PinInputPullup
+	PinOutput
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var DefaultUART = UART0
+```
+
+Always use UART0 as the serial output.
+
+
+```go
+var (
+	// UART0 is the hardware serial port on the AVR.
+	UART0	= &_UART0
+	_UART0	= UART{
+		Buffer:	NewRingBuffer(),
+
+		dataReg:	avr.UDR0,
+		baudRegH:	avr.UBRR0H,
+		baudRegL:	avr.UBRR0L,
+		statusRegA:	avr.UCSR0A,
+		statusRegB:	avr.UCSR0B,
+		statusRegC:	avr.UCSR0C,
+	}
+)
+```
+
+UART
+
+
+```go
+var (
+	Timer0	= PWM{0}	// 8 bit timer for PD5 and PD6
+	Timer1	= PWM{1}	// 16 bit timer for PB1 and PB2
+	Timer2	= PWM{2}	// 8 bit timer for PB3 and PD3
+)
+```
+
+
+
+```go
+var I2C0 = &I2C{
+	srReg:	avr.TWSR,
+	brReg:	avr.TWBR,
+	crReg:	avr.TWCR,
+	drReg:	avr.TWDR,
+	srPS0:	avr.TWSR_TWPS0,
+	srPS1:	avr.TWSR_TWPS1,
+	crEN:	avr.TWCR_TWEN,
+	crINT:	avr.TWCR_TWINT,
+	crSTO:	avr.TWCR_TWSTO,
+	crEA:	avr.TWCR_TWEA,
+	crSTA:	avr.TWCR_TWSTA,
+}
+```
+
+I2C0 is the only I2C interface on most AVRs.
+
+
+```go
+var SPI0 = &SPI{
+	spcr:	avr.SPCR,
+	spdr:	avr.SPDR,
+	spsr:	avr.SPSR,
+
+	spcrR0:		avr.SPCR_SPR0,
+	spcrR1:		avr.SPCR_SPR1,
+	spcrCPHA:	avr.SPCR_CPHA,
+	spcrCPOL:	avr.SPCR_CPOL,
+	spcrDORD:	avr.SPCR_DORD,
+	spcrSPE:	avr.SPCR_SPE,
+	spcrMSTR:	avr.SPCR_MSTR,
+
+	spsrI2X:	avr.SPSR_SPI2X,
+	spsrSPIF:	avr.SPSR_SPIF,
+
+	sck:	PB5,
+	sdo:	PB3,
+	sdi:	PB4,
+	cs:	PB2,
+}
+```
+
+SPI configuration
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+Return the current CPU frequency in hertz.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(ADCConfig)
+```
+
+Configure configures a ADCPin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff. The AVR
+has an ADC of 10 bits precision so the lower 6 bits will be zero.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	srReg	*volatile.Register8
+	brReg	*volatile.Register8
+	crReg	*volatile.Register8
+	drReg	*volatile.Register8
+
+	srPS0	byte
+	srPS1	byte
+	crEN	byte
+	crINT	byte
+	crSTO	byte
+	crEA	byte
+	crSTA	byte
+}
+```
+
+I2C on AVR.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency uint32
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWM
+
+```go
+type PWM struct {
+	num uint8
+}
+```
+
+PWM is one PWM peripheral, which consists of a counter and two output
+channels (that can be connected to two fixed pins). You can set the frequency
+using SetPeriod, but only for all the channels in this PWM peripheral at
+once.
+
+
+
+### func (PWM) Channel
+
+```go
+func (pwm PWM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (PWM) Configure
+
+```go
+func (pwm PWM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+
+For the two 8 bit timers, there is only a limited number of periods
+available, namely the CPU frequency divided by 256 and again divided by 1, 8,
+64, 256, or 1024. For a MCU running at 16MHz, this would be a period of 16µs,
+128µs, 1024µs, 4096µs, or 16384µs.
+
+
+### func (PWM) Counter
+
+```go
+func (pwm PWM) Counter() uint32
+```
+
+Counter returns the current counter value of the timer in this PWM
+peripheral. It may be useful for debugging.
+
+
+### func (PWM) Period
+
+```go
+func (pwm PWM) Period() uint64
+```
+
+Period returns the used PWM period in nanoseconds. It might deviate slightly
+from the configured period due to rounding.
+
+
+### func (PWM) Set
+
+```go
+func (pwm PWM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle, in other words the fraction of time the channel output is high (or low
+when inverted). For example, to set it to a 25% duty cycle, use:
+
+	pwm.Set(channel, pwm.Top() / 4)
+
+pwm.Set(channel, 0) will set the output to low and pwm.Set(channel,
+pwm.Top()) will set the output to high, assuming the output isn't inverted.
+
+
+### func (PWM) SetInverting
+
+```go
+func (pwm PWM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+Note: the invert state may not be applied on the AVR until the next call to
+ch.Set().
+
+
+### func (PWM) SetPeriod
+
+```go
+func (pwm PWM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (PWM) Top
+
+```go
+func (pwm PWM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to Set
+(see Set documentation for more information).
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure sets the pin to input or output.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*volatile.Register8, uint8)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+Warning: there are no separate pin set/clear registers on the AVR. The
+returned mask is only valid as long as no other pin in the same port has been
+changed.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*volatile.Register8, uint8)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+Warning: there are no separate pin set/clear registers on the AVR. The
+returned mask is only valid as long as no other pin in the same port has been
+changed.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set changes the value of the GPIO pin. The pin must be configured as output.
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (pin Pin) SetInterrupt(pinChange PinChange, callback func(Pin)) (err error)
+```
+
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+Pin Change Interrupts
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	// The registers for the SPIx port set by the chip
+	spcr	*volatile.Register8
+	spdr	*volatile.Register8
+	spsr	*volatile.Register8
+
+	spcrR0		byte
+	spcrR1		byte
+	spcrCPHA	byte
+	spcrCPOL	byte
+	spcrDORD	byte
+	spcrSPE		byte
+	spcrMSTR	byte
+
+	spsrI2X		byte
+	spsrSPIF	byte
+
+	// The io pins for the SPIx port set by the chip
+	sck	Pin
+	sdi	Pin
+	sdo	Pin
+	cs	Pin
+}
+```
+
+SPI is for the Serial Peripheral Interface
+Data is taken from http://ww1.microchip.com/downloads/en/DeviceDoc/ATmega48A-PA-88A-PA-168A-PA-328-P-DS-DS40002061A.pdf page 169 and following
+
+
+
+### func (*SPI) Configure
+
+```go
+func (s *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (s *SPI) Transfer(b byte) (byte, error)
+```
+
+Transfer writes the byte into the register and returns the read content
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer	*RingBuffer
+
+	dataReg		*volatile.Register8
+	baudRegH	*volatile.Register8
+	baudRegL	*volatile.Register8
+
+	statusRegA	*volatile.Register8
+	statusRegB	*volatile.Register8
+	statusRegC	*volatile.Register8
+}
+```
+
+UART on the AVR.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART on the AVR. Defaults to 9600 baud on Arduino.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/atsame54-xpro.md b/content/docs/reference/microcontrollers/machine/atsame54-xpro.md
new file mode 100644
index 00000000..652bba6a
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/atsame54-xpro.md
@@ -0,0 +1,2135 @@
+
+---
+title: atsame54-xpro
+---
+
+
+## Constants
+
+```go
+const (
+	LED	= PC18
+	BUTTON	= PB31
+)
+```
+
+
+
+```go
+const (
+
+	// Extension Header EXT1
+	EXT1_PIN3_ADC_P		= PB04
+	EXT1_PIN4_ADC_N		= PB05
+	EXT1_PIN5_GPIO1		= PA06
+	EXT1_PIN6_GPIO2		= PA07
+	EXT1_PIN7_PWM_P		= PB08
+	EXT1_PIN8_PWM_N		= PB09
+	EXT1_PIN9_IRQ		= PB07
+	EXT1_PIN9_GPIO		= PB07
+	EXT1_PIN10_SPI_SS_B	= PA27
+	EXT1_PIN10_GPIO		= PA27
+	EXT1_PIN11_TWI_SDA	= PA22
+	EXT1_PIN12_TWI_SCL	= PA23
+	EXT1_PIN13_UART_RX	= PA05
+	EXT1_PIN14_UART_TX	= PA04
+	EXT1_PIN15_SPI_SS_A	= PB28
+	EXT1_PIN16_SPI_SDO	= PB27
+	EXT1_PIN17_SPI_SDI	= PB29
+	EXT1_PIN18_SPI_SCK	= PB26
+
+	// Extension Header EXT2
+	EXT2_PIN3_ADC_P		= PB00
+	EXT2_PIN4_ADC_N		= PA03
+	EXT2_PIN5_GPIO1		= PB01
+	EXT2_PIN6_GPIO2		= PB06
+	EXT2_PIN7_PWM_P		= PB14
+	EXT2_PIN8_PWM_N		= PB15
+	EXT2_PIN9_IRQ		= PD00
+	EXT2_PIN9_GPIO		= PD00
+	EXT2_PIN10_SPI_SS_B	= PB02
+	EXT2_PIN10_GPIO		= PB02
+	EXT2_PIN11_TWI_SDA	= PD08
+	EXT2_PIN12_TWI_SCL	= PD09
+	EXT2_PIN13_UART_RX	= PB17
+	EXT2_PIN14_UART_TX	= PB16
+	EXT2_PIN15_SPI_SS_A	= PC06
+	EXT2_PIN16_SPI_SDO	= PC04
+	EXT2_PIN17_SPI_SDI	= PC07
+	EXT2_PIN18_SPI_SCK	= PC05
+
+	// Extension Header EXT3
+	EXT3_PIN3_ADC_P		= PC02
+	EXT3_PIN4_ADC_N		= PC03
+	EXT3_PIN5_GPIO1		= PC01
+	EXT3_PIN6_GPIO2		= PC10
+	EXT3_PIN7_PWM_P		= PD10
+	EXT3_PIN8_PWM_N		= PD11
+	EXT3_PIN9_IRQ		= PC30
+	EXT3_PIN9_GPIO		= PC30
+	EXT3_PIN10_SPI_SS_B	= PC31
+	EXT3_PIN10_GPIO		= PC31
+	EXT3_PIN11_TWI_SDA	= PD08
+	EXT3_PIN12_TWI_SCL	= PD09
+	EXT3_PIN13_UART_RX	= PC23
+	EXT3_PIN14_UART_TX	= PC22
+	EXT3_PIN15_SPI_SS_A	= PC14
+	EXT3_PIN16_SPI_SDO	= PC04
+	EXT3_PIN17_SPI_SDI	= PC07
+	EXT3_PIN18_SPI_SCK	= PC05
+
+	// SD_CARD
+	SD_CARD_MCDA0	= PB18
+	SD_CARD_MCDA1	= PB19
+	SD_CARD_MCDA2	= PB20
+	SD_CARD_MCDA3	= PB21
+	SD_CARD_MCCK	= PA21
+	SD_CARD_MCCDA	= PA20
+	SD_CARD_DETECT	= PD20
+	SD_CARD_PROTECT	= PD21
+
+	// I2C
+	I2C_SDA	= PD08
+	I2C_SCL	= PD09
+
+	// CAN
+	CAN0_TX	= PA22
+	CAN0_RX	= PA23
+
+	CAN1_STANDBY	= PC13
+	CAN1_TX		= PB12
+	CAN1_RX		= PB13
+
+	CAN_STANDBY	= CAN1_STANDBY
+	CAN_TX		= CAN1_TX
+	CAN_RX		= CAN1_RX
+
+	// PDEC
+	PDEC_PHASE_A	= PC16
+	PDEC_PHASE_B	= PC17
+	PDEC_INDEX	= PC18
+
+	// PCC
+	PCC_I2C_SDA	= PD08
+	PCC_I2C_SCL	= PD09
+	PCC_VSYNC_DEN1	= PA12
+	PCC_HSYNC_DEN2	= PA13
+	PCC_CLK		= PA14
+	PCC_XCLK	= PA15
+	PCC_DATA00	= PA16
+	PCC_DATA01	= PA17
+	PCC_DATA02	= PA18
+	PCC_DATA03	= PA19
+	PCC_DATA04	= PA20
+	PCC_DATA05	= PA21
+	PCC_DATA06	= PA22
+	PCC_DATA07	= PA23
+	PCC_DATA08	= PB14
+	PCC_DATA09	= PB15
+	PCC_RESET	= PC12
+	PCC_PWDN	= PC11
+
+	// Ethernet
+	ETHERNET_TXCK	= PA14
+	ETHERNET_TXEN	= PA17
+	ETHERNET_TX0	= PA18
+	ETHERNET_TX1	= PA19
+	ETHERNET_RXER	= PA15
+	ETHERNET_RX0	= PA13
+	ETHERNET_RX1	= PA12
+	ETHERNET_RXDV	= PC20
+	ETHERNET_MDIO	= PC12
+	ETHERNET_MDC	= PC11
+	ETHERNET_INT	= PD12
+	ETHERNET_RESET	= PC21
+
+	PIN_QT_BUTTON	= PA16
+	PIN_BTN0	= PB31
+	PIN_ETH_LED	= PC15
+	PIN_LED0	= PC18
+	PIN_ADC_DAC	= PA02
+	PIN_VBUS_DETECT	= PC00
+	PIN_USB_ID	= PC19
+)
+```
+
+
+
+```go
+const (
+	USBCDC_DM_PIN	= PA24
+	USBCDC_DP_PIN	= PA25
+)
+```
+
+USBCDC pins
+
+
+```go
+const (
+	// Extension Header EXT1
+	UART_TX_PIN	= PA04	// TX : SERCOM0/PAD[0]
+	UART_RX_PIN	= PA05	// RX : SERCOM0/PAD[1]
+
+	// Extension Header EXT2
+	UART2_TX_PIN	= PB16	// TX : SERCOM5/PAD[0]
+	UART2_RX_PIN	= PB17	// RX : SERCOM5/PAD[1]
+
+	// Extension Header EXT3
+	UART3_TX_PIN	= PC22	// TX : SERCOM1/PAD[0]
+	UART3_RX_PIN	= PC23	// RX : SERCOM1/PAD[1]
+
+	// Virtual COM Port
+	UART4_TX_PIN	= PB25	// TX : SERCOM2/PAD[0]
+	UART4_RX_PIN	= PB24	// RX : SERCOM2/PAD[1]
+)
+```
+
+UART pins
+
+
+```go
+const (
+	// Extension Header EXT1
+	SDA0_PIN	= PA22	// SDA: SERCOM3/PAD[0]
+	SCL0_PIN	= PA23	// SCL: SERCOM3/PAD[1]
+
+	// Extension Header EXT2
+	SDA1_PIN	= PD08	// SDA: SERCOM7/PAD[0]
+	SCL1_PIN	= PD09	// SCL: SERCOM7/PAD[1]
+
+	// Extension Header EXT3
+	SDA2_PIN	= PD08	// SDA: SERCOM7/PAD[0]
+	SCL2_PIN	= PD09	// SCL: SERCOM7/PAD[1]
+
+	// Data Gateway Interface
+	SDA_DGI_PIN	= PD08	// SDA: SERCOM7/PAD[0]
+	SCL_DGI_PIN	= PD09	// SCL: SERCOM7/PAD[1]
+
+	SDA_PIN	= SDA0_PIN
+	SCL_PIN	= SCL0_PIN
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	// Extension Header EXT1
+	SPI0_SCK_PIN	= PB26	// SCK: SERCOM4/PAD[1]
+	SPI0_SDO_PIN	= PB27	// SDO: SERCOM4/PAD[0]
+	SPI0_SDI_PIN	= PB29	// SDI: SERCOM4/PAD[3]
+	SPI0_SS_PIN	= PB28	// SS : SERCOM4/PAD[2]
+
+	// Extension Header EXT2
+	SPI1_SCK_PIN	= PC05	// SCK: SERCOM6/PAD[1]
+	SPI1_SDO_PIN	= PC04	// SDO: SERCOM6/PAD[0]
+	SPI1_SDI_PIN	= PC07	// SDI: SERCOM6/PAD[3]
+	SPI1_SS_PIN	= PC06	// SS : SERCOM6/PAD[2]
+
+	// Extension Header EXT3
+	SPI2_SCK_PIN	= PC05	// SCK: SERCOM6/PAD[1]
+	SPI2_SDO_PIN	= PC04	// SDO: SERCOM6/PAD[0]
+	SPI2_SDI_PIN	= PC07	// SDI: SERCOM6/PAD[3]
+	SPI2_SS_PIN	= PC14	// SS : GPIO
+
+	// Data Gateway Interface
+	SPI_DGI_SCK_PIN	= PC05	// SCK: SERCOM6/PAD[1]
+	SPI_DGI_SDO_PIN	= PC04	// SDO: SERCOM6/PAD[0]
+	SPI_DGI_SDI_PIN	= PC07	// SDI: SERCOM6/PAD[3]
+	SPI_DGI_SS_PIN	= PD01	// SS : GPIO
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinAnalog		PinMode	= 1
+	PinSERCOM		PinMode	= 2
+	PinSERCOMAlt		PinMode	= 3
+	PinTimer		PinMode	= 4
+	PinTimerAlt		PinMode	= 5
+	PinTCCPDEC		PinMode	= 6
+	PinCom			PinMode	= 7
+	PinSDHC			PinMode	= 8
+	PinI2S			PinMode	= 9
+	PinPCC			PinMode	= 10
+	PinGMAC			PinMode	= 11
+	PinACCLK		PinMode	= 12
+	PinCCL			PinMode	= 13
+	PinDigital		PinMode	= 14
+	PinInput		PinMode	= 15
+	PinInputPullup		PinMode	= 16
+	PinOutput		PinMode	= 17
+	PinTCCE			PinMode	= PinTimer
+	PinTCCF			PinMode	= PinTimerAlt
+	PinTCCG			PinMode	= PinTCCPDEC
+	PinInputPulldown	PinMode	= 18
+	PinCAN			PinMode	= 19
+	PinCAN0			PinMode	= PinSDHC
+	PinCAN1			PinMode	= PinCom
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
+	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
+	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	PA00	Pin	= 0
+	PA01	Pin	= 1
+	PA02	Pin	= 2
+	PA03	Pin	= 3
+	PA04	Pin	= 4
+	PA05	Pin	= 5
+	PA06	Pin	= 6
+	PA07	Pin	= 7
+	PA08	Pin	= 8	// peripherals: TCC0 channel 0, TCC1 channel 4, sercomI2CM0 SDA, sercomI2CM2 SDA
+	PA09	Pin	= 9	// peripherals: TCC0 channel 1, TCC1 channel 5, sercomI2CM0 SCL, sercomI2CM2 SCL
+	PA10	Pin	= 10	// peripherals: TCC0 channel 2, TCC1 channel 6
+	PA11	Pin	= 11	// peripherals: TCC0 channel 3, TCC1 channel 7
+	PA12	Pin	= 12	// peripherals: TCC0 channel 6, TCC1 channel 2, sercomI2CM2 SDA, sercomI2CM4 SDA
+	PA13	Pin	= 13	// peripherals: TCC0 channel 7, TCC1 channel 3, sercomI2CM2 SCL, sercomI2CM4 SCL
+	PA14	Pin	= 14	// peripherals: TCC2 channel 0, TCC1 channel 2
+	PA15	Pin	= 15	// peripherals: TCC2 channel 1, TCC1 channel 3
+	PA16	Pin	= 16	// peripherals: TCC1 channel 0, TCC0 channel 4, sercomI2CM1 SDA, sercomI2CM3 SDA
+	PA17	Pin	= 17	// peripherals: TCC1 channel 1, TCC0 channel 5, sercomI2CM1 SCL, sercomI2CM3 SCL
+	PA18	Pin	= 18	// peripherals: TCC1 channel 2, TCC0 channel 6
+	PA19	Pin	= 19	// peripherals: TCC1 channel 3, TCC0 channel 7
+	PA20	Pin	= 20	// peripherals: TCC1 channel 4, TCC0 channel 0
+	PA21	Pin	= 21	// peripherals: TCC1 channel 5, TCC0 channel 1
+	PA22	Pin	= 22	// peripherals: TCC1 channel 6, TCC0 channel 2, sercomI2CM3 SDA, sercomI2CM5 SDA
+	PA23	Pin	= 23	// peripherals: TCC1 channel 7, TCC0 channel 3, sercomI2CM3 SCL, sercomI2CM5 SCL
+	PA24	Pin	= 24	// peripherals: TCC2 channel 2
+	PA25	Pin	= 25	// peripherals: TCC2 channel 3
+	PA26	Pin	= 26
+	PA27	Pin	= 27
+	PA28	Pin	= 28
+	PA29	Pin	= 29
+	PA30	Pin	= 30	// peripherals: TCC2 channel 0
+	PA31	Pin	= 31	// peripherals: TCC2 channel 1
+	PB00	Pin	= 32
+	PB01	Pin	= 33
+	PB02	Pin	= 34	// peripherals: TCC2 channel 2
+	PB03	Pin	= 35	// peripherals: TCC2 channel 3
+	PB04	Pin	= 36
+	PB05	Pin	= 37
+	PB06	Pin	= 38
+	PB07	Pin	= 39
+	PB08	Pin	= 40
+	PB09	Pin	= 41
+	PB10	Pin	= 42	// peripherals: TCC0 channel 4, TCC1 channel 0
+	PB11	Pin	= 43	// peripherals: TCC0 channel 5, TCC1 channel 1
+	PB12	Pin	= 44	// peripherals: TCC3 channel 0, TCC0 channel 0
+	PB13	Pin	= 45	// peripherals: TCC3 channel 1, TCC0 channel 1
+	PB14	Pin	= 46	// peripherals: TCC4 channel 0, TCC0 channel 2
+	PB15	Pin	= 47	// peripherals: TCC4 channel 1, TCC0 channel 3
+	PB16	Pin	= 48	// peripherals: TCC3 channel 0, TCC0 channel 4
+	PB17	Pin	= 49	// peripherals: TCC3 channel 1, TCC0 channel 5
+	PB18	Pin	= 50	// peripherals: TCC1 channel 0
+	PB19	Pin	= 51	// peripherals: TCC1 channel 1
+	PB20	Pin	= 52	// peripherals: TCC1 channel 2
+	PB21	Pin	= 53	// peripherals: TCC1 channel 3
+	PB22	Pin	= 54
+	PB23	Pin	= 55
+	PB24	Pin	= 56
+	PB25	Pin	= 57
+	PB26	Pin	= 58	// peripherals: TCC1 channel 2
+	PB27	Pin	= 59	// peripherals: TCC1 channel 3
+	PB28	Pin	= 60	// peripherals: TCC1 channel 4
+	PB29	Pin	= 61	// peripherals: TCC1 channel 5
+	PB30	Pin	= 62	// peripherals: TCC4 channel 0, TCC0 channel 6
+	PB31	Pin	= 63	// peripherals: TCC4 channel 1, TCC0 channel 7
+	PC00	Pin	= 64
+	PC01	Pin	= 65
+	PC02	Pin	= 66
+	PC03	Pin	= 67
+	PC04	Pin	= 68	// peripherals: TCC0 channel 0
+	PC05	Pin	= 69	// peripherals: TCC0 channel 1
+	PC06	Pin	= 70
+	PC07	Pin	= 71
+	PC08	Pin	= 72
+	PC09	Pin	= 73
+	PC10	Pin	= 74	// peripherals: TCC0 channel 0, TCC1 channel 4
+	PC11	Pin	= 75	// peripherals: TCC0 channel 1, TCC1 channel 5
+	PC12	Pin	= 76	// peripherals: TCC0 channel 2, TCC1 channel 6
+	PC13	Pin	= 77	// peripherals: TCC0 channel 3, TCC1 channel 7
+	PC14	Pin	= 78	// peripherals: TCC0 channel 4, TCC1 channel 0
+	PC15	Pin	= 79	// peripherals: TCC0 channel 5, TCC1 channel 1
+	PC16	Pin	= 80	// peripherals: TCC0 channel 0
+	PC17	Pin	= 81	// peripherals: TCC0 channel 1
+	PC18	Pin	= 82	// peripherals: TCC0 channel 2
+	PC19	Pin	= 83	// peripherals: TCC0 channel 3
+	PC20	Pin	= 84	// peripherals: TCC0 channel 4
+	PC21	Pin	= 85	// peripherals: TCC0 channel 5
+	PC22	Pin	= 86	// peripherals: TCC0 channel 6
+	PC23	Pin	= 87	// peripherals: TCC0 channel 7
+	PC24	Pin	= 88
+	PC25	Pin	= 89
+	PC26	Pin	= 90
+	PC27	Pin	= 91
+	PC28	Pin	= 92
+	PC29	Pin	= 93
+	PC30	Pin	= 94
+	PC31	Pin	= 95
+	PD00	Pin	= 96
+	PD01	Pin	= 97
+	PD02	Pin	= 98
+	PD03	Pin	= 99
+	PD04	Pin	= 100
+	PD05	Pin	= 101
+	PD06	Pin	= 102
+	PD07	Pin	= 103
+	PD08	Pin	= 104	// peripherals: TCC0 channel 1, sercomI2CM6 SDA, sercomI2CM7 SDA
+	PD09	Pin	= 105	// peripherals: TCC0 channel 2, sercomI2CM6 SCL, sercomI2CM7 SCL
+	PD10	Pin	= 106	// peripherals: TCC0 channel 3
+	PD11	Pin	= 107	// peripherals: TCC0 channel 4
+	PD12	Pin	= 108	// peripherals: TCC0 channel 5
+	PD13	Pin	= 109	// peripherals: TCC0 channel 6
+	PD14	Pin	= 110
+	PD15	Pin	= 111
+	PD16	Pin	= 112
+	PD17	Pin	= 113
+	PD18	Pin	= 114
+	PD19	Pin	= 115
+	PD20	Pin	= 116	// peripherals: TCC1 channel 0
+	PD21	Pin	= 117	// peripherals: TCC1 channel 1
+	PD22	Pin	= 118
+	PD23	Pin	= 119
+	PD24	Pin	= 120
+	PD25	Pin	= 121
+	PD26	Pin	= 122
+	PD27	Pin	= 123
+	PD28	Pin	= 124
+	PD29	Pin	= 125
+	PD30	Pin	= 126
+	PD31	Pin	= 127
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	// SERCOM_FREQ_REF is always reference frequency on SAMD51 regardless of CPU speed.
+	SERCOM_FREQ_REF		= 48000000
+	SERCOM_FREQ_REF_GCLK0	= 120000000
+
+	// Default rise time in nanoseconds, based on 4.7K ohm pull up resistors
+	riseTimeNanoseconds	= 125
+
+	// wire bus states
+	wireUnknownState	= 0
+	wireIdleState		= 1
+	wireOwnerState		= 2
+	wireBusyState		= 3
+
+	// wire commands
+	wireCmdNoAction		= 0
+	wireCmdRepeatStart	= 1
+	wireCmdRead		= 2
+	wireCmdStop		= 3
+)
+```
+
+
+
+```go
+const (
+	QSPI_SCK	= PB10
+	QSPI_CS		= PB11
+	QSPI_DATA0	= PA08
+	QSPI_DATA1	= PA09
+	QSPI_DATA2	= PA10
+	QSPI_DATA3	= PA11
+)
+```
+
+The QSPI peripheral on ATSAMD51 is only available on the following pins
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (16s)
+	WatchdogMaxTimeout = (16384 * 1000) / 1024	// CYC16384/1024kHz
+)
+```
+
+
+
+```go
+const (
+	// these are SAMD51 specific.
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Pos	= 0
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Mask	= 0x3FFF
+
+	usb_DEVICE_PCKSIZE_SIZE_Pos	= 28
+	usb_DEVICE_PCKSIZE_SIZE_Mask	= 0x7
+
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Pos	= 14
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Mask	= 0x3FFF
+
+	NumberOfUSBEndpoints	= 8
+)
+```
+
+
+
+```go
+const HSRAM_SIZE = 0x00040000
+```
+
+
+
+```go
+const (
+	CANRxFifoSize	= 16
+	CANTxFifoSize	= 16
+	CANEvFifoSize	= 16
+)
+```
+
+
+
+```go
+const (
+	CANTransferRate125kbps	CANTransferRate	= 125000
+	CANTransferRate250kbps	CANTransferRate	= 250000
+	CANTransferRate500kbps	CANTransferRate	= 500000
+	CANTransferRate1000kbps	CANTransferRate	= 1000000
+	CANTransferRate2000kbps	CANTransferRate	= 2000000
+	CANTransferRate4000kbps	CANTransferRate	= 4000000
+)
+```
+
+CAN transfer rates for CANConfig
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	// Extension Header EXT1
+	UART1	= &sercomUSART0
+
+	// Extension Header EXT2
+	UART2	= &sercomUSART5
+
+	// Extension Header EXT3
+	UART3	= &sercomUSART1
+
+	// EDBG Virtual COM Port
+	UART4	= &sercomUSART2
+)
+```
+
+UART on the SAM E54 Xplained Pro
+
+
+```go
+var (
+	// Extension Header EXT1
+	I2C0	= sercomI2CM3
+
+	// Extension Header EXT2
+	I2C1	= sercomI2CM7
+
+	// Extension Header EXT3
+	I2C2	= sercomI2CM7
+
+	// Data Gateway Interface
+	I2C3	= sercomI2CM7
+)
+```
+
+I2C on the SAM E54 Xplained Pro
+
+
+```go
+var (
+	// Extension Header EXT1
+	SPI0	= sercomSPIM4
+
+	// Extension Header EXT2
+	SPI1	= sercomSPIM6
+
+	// Extension Header EXT3
+	SPI2	= sercomSPIM6
+
+	// Data Gateway Interface
+	SPI3	= sercomSPIM6
+)
+```
+
+SPI on the SAM E54 Xplained Pro
+
+
+```go
+var (
+	CAN0	= CAN{
+		Bus: sam.CAN0,
+	}
+
+	CAN1	= CAN{
+		Bus: sam.CAN1,
+	}
+)
+```
+
+CAN on the SAM E54 Xplained Pro
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	DAC0	= DAC{Channel: 0}
+	DAC1	= DAC{Channel: 1}
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the SAMD51.
+
+
+```go
+var (
+	TCC0	= (*TCC)(sam.TCC0)
+	TCC1	= (*TCC)(sam.TCC1)
+	TCC2	= (*TCC)(sam.TCC2)
+	TCC3	= (*TCC)(sam.TCC3)
+	TCC4	= (*TCC)(sam.TCC4)
+)
+```
+
+This chip has five TCC peripherals, which have PWM as one feature.
+
+
+```go
+var CANRxFifo [2][(8 + 64) * CANRxFifoSize]byte
+```
+
+
+
+```go
+var CANTxFifo [2][(8 + 64) * CANTxFifoSize]byte
+```
+
+
+
+```go
+var CANEvFifo [2][(8) * CANEvFifoSize]byte
+```
+
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CANDlcToLength
+
+```go
+func CANDlcToLength(dlc byte, isFD bool) byte
+```
+
+CANDlcToLength() converts a DLC value to its actual length.
+
+
+### func CANLengthToDlc
+
+```go
+func CANLengthToDlc(length byte, isFD bool) byte
+```
+
+CANLengthToDlc() converts its actual length to a DLC value.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) and 16 bytes (128 bits) are common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of cryptographically secure random data
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig)
+```
+
+Configure configures a ADCPin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type CAN
+
+```go
+type CAN struct {
+	Bus *sam.CAN_Type
+}
+```
+
+
+
+
+### func (*CAN) Configure
+
+```go
+func (can *CAN) Configure(config CANConfig) error
+```
+
+Configure this CAN peripheral with the given configuration.
+
+
+### func (*CAN) Rx
+
+```go
+func (can *CAN) Rx() (id uint32, dlc byte, data []byte, isFd, isExtendedID bool)
+```
+
+Rx receives a CAN frame. It is easier to use than RxRaw, but not as
+flexible.
+
+
+### func (*CAN) RxFifoIsEmpty
+
+```go
+func (can *CAN) RxFifoIsEmpty() bool
+```
+
+RxFifoIsEmpty returns whether RxFifo is empty or not.
+
+
+### func (*CAN) RxFifoIsFull
+
+```go
+func (can *CAN) RxFifoIsFull() bool
+```
+
+RxFifoIsFull returns whether RxFifo is full or not.
+
+
+### func (*CAN) RxFifoSize
+
+```go
+func (can *CAN) RxFifoSize() int
+```
+
+RxFifoSize returns the number of CAN Frames currently stored in the RXFifo.
+
+
+### func (*CAN) RxRaw
+
+```go
+func (can *CAN) RxRaw(e *CANRxBufferElement)
+```
+
+RxRaw copies the received CAN frame to CANRxBufferElement.
+
+
+### func (*CAN) SetInterrupt
+
+```go
+func (can *CAN) SetInterrupt(ie uint32, callback func(*CAN)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular CAN state.
+
+This call will replace a previously set callback. You can pass a nil func
+to unset the CAN interrupt. If you do so, the change parameter is ignored
+and can be set to any value (such as 0).
+
+
+### func (*CAN) Tx
+
+```go
+func (can *CAN) Tx(id uint32, data []byte, isFD, isExtendedID bool)
+```
+
+The Tx transmits CAN frames. It is easier to use than TxRaw, but not as
+flexible.
+
+
+### func (*CAN) TxFifoFreeLevel
+
+```go
+func (can *CAN) TxFifoFreeLevel() int
+```
+
+TxFifoFreeLevel returns how many messages can still be set in the TxFifo.
+
+
+### func (*CAN) TxFifoIsFull
+
+```go
+func (can *CAN) TxFifoIsFull() bool
+```
+
+TxFifoIsFull returns whether TxFifo is full or not.
+
+
+### func (*CAN) TxRaw
+
+```go
+func (can *CAN) TxRaw(e *CANTxBufferElement)
+```
+
+TxRaw sends a CAN Frame according to CANTxBufferElement.
+
+
+
+
+## type CANConfig
+
+```go
+type CANConfig struct {
+	TransferRate	CANTransferRate
+	TransferRateFD	CANTransferRate
+	Tx		Pin
+	Rx		Pin
+	Standby		Pin
+}
+```
+
+CANConfig holds CAN configuration parameters. Tx and Rx need to be
+specified with some pins. When the Standby Pin is specified, configure it
+as an output pin and output Low in Configure(). If this operation is not
+necessary, specify NoPin.
+
+
+
+
+
+## type CANRxBufferElement
+
+```go
+type CANRxBufferElement struct {
+	ESI	bool
+	XTD	bool
+	RTR	bool
+	ID	uint32
+	ANMF	bool
+	FIDX	uint8
+	FDF	bool
+	BRS	bool
+	DLC	uint8
+	RXTS	uint16
+	DB	[64]uint8
+}
+```
+
+CANRxBufferElement is a struct that corresponds to the same5x Rx Buffer and
+FIFO Element.
+
+
+
+### func (CANRxBufferElement) Data
+
+```go
+func (e CANRxBufferElement) Data() []byte
+```
+
+Data returns the received data as a slice of the size according to dlc.
+
+
+### func (CANRxBufferElement) Length
+
+```go
+func (e CANRxBufferElement) Length() byte
+```
+
+Length returns its actual length.
+
+
+
+
+## type CANTransferRate
+
+```go
+type CANTransferRate uint32
+```
+
+
+
+
+
+
+## type CANTxBufferElement
+
+```go
+type CANTxBufferElement struct {
+	ESI	bool
+	XTD	bool
+	RTR	bool
+	ID	uint32
+	MM	uint8
+	EFC	bool
+	FDF	bool
+	BRS	bool
+	DLC	uint8
+	DB	[64]uint8
+}
+```
+
+CANTxBufferElement is a struct that corresponds to the same5x' Tx Buffer
+Element.
+
+
+
+
+
+## type DAC
+
+```go
+type DAC struct {
+	Channel uint8
+}
+```
+
+DAC on the SAMD51.
+
+
+
+### func (DAC) Configure
+
+```go
+func (dac DAC) Configure(config DACConfig)
+```
+
+Configure the DAC.
+output pin must already be configured.
+
+
+### func (DAC) Set
+
+```go
+func (dac DAC) Set(value uint16) error
+```
+
+Set writes a single 16-bit value to the DAC.
+Since the ATSAMD51 only has a 12-bit DAC, the passed-in value will be scaled down.
+
+
+
+
+## type DACConfig
+
+```go
+type DACConfig struct {
+}
+```
+
+DACConfig placeholder for future expansion.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*sam.SERCOM_I2CM_Type
+	SERCOM	uint8
+}
+```
+
+I2C on the SAMD51.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteByte
+
+```go
+func (i2c *I2C) WriteByte(data byte) error
+```
+
+WriteByte writes a single byte to the I2C bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when configured as an input or as
+an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+### func (Pin) Toggle
+
+```go
+func (p Pin) Toggle()
+```
+
+Toggle switches an output pin from low to high or from high to low.
+Warning: only use this on an output pin!
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*sam.SERCOM_SPIM_Type
+	SERCOM	uint8
+}
+```
+
+SPI
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type TCC
+
+```go
+type TCC sam.TCC_Type
+```
+
+TCC is one timer peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this timer peripheral at
+once.
+
+
+
+### func (*TCC) Channel
+
+```go
+func (tcc *TCC) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin. Note that one channel may be
+shared between multiple pins, and so will have the same duty cycle. If this
+is not desirable, look for a different TCC or consider using a different pin.
+
+
+### func (*TCC) Configure
+
+```go
+func (tcc *TCC) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this TCC.
+
+
+### func (*TCC) Counter
+
+```go
+func (tcc *TCC) Counter() uint32
+```
+
+Counter returns the current counter value of the timer in this TCC
+peripheral. It may be useful for debugging.
+
+
+### func (*TCC) Set
+
+```go
+func (tcc *TCC) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle, in other words the fraction of time the channel output is high (or low
+when inverted). For example, to set it to a 25% duty cycle, use:
+
+	tcc.Set(channel, tcc.Top() / 4)
+
+tcc.Set(channel, 0) will set the output to low and tcc.Set(channel,
+tcc.Top()) will set the output to high, assuming the output isn't inverted.
+
+
+### func (*TCC) SetInverting
+
+```go
+func (tcc *TCC) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TCC) SetPeriod
+
+```go
+func (tcc *TCC) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this TCC peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the TCC peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TCC) Top
+
+```go
+func (tcc *TCC) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+tcc.Set (see tcc.Set for more information).
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*sam.SERCOM_USART_INT_Type
+	SERCOM		uint8
+	Interrupt	interrupt.Interrupt	// RXC interrupt
+}
+```
+
+UART on the SAMD51.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/badger2040-w.md b/content/docs/reference/microcontrollers/machine/badger2040-w.md
new file mode 100644
index 00000000..a9b70569
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/badger2040-w.md
@@ -0,0 +1,1672 @@
+
+---
+title: badger2040-w
+---
+
+
+## Constants
+
+```go
+const (
+	LED	Pin	= GPIO22
+
+	BUTTON_A	Pin	= GPIO12
+	BUTTON_B	Pin	= GPIO13
+	BUTTON_C	Pin	= GPIO14
+	BUTTON_UP	Pin	= GPIO15
+	BUTTON_DOWN	Pin	= GPIO11
+	BUTTON_USER	Pin	= NoPin	// Not available on Badger 2040 W
+
+	EPD_BUSY_PIN	Pin	= GPIO26
+	EPD_RESET_PIN	Pin	= GPIO21
+	EPD_DC_PIN	Pin	= GPIO20
+	EPD_CS_PIN	Pin	= GPIO17
+	EPD_SCK_PIN	Pin	= GPIO18
+	EPD_SDO_PIN	Pin	= GPIO19
+
+	VBUS_DETECT	Pin	= GPIO24
+	VREF_POWER	Pin	= GPIO27
+	VREF_1V24	Pin	= GPIO28
+	VBAT_SENSE	Pin	= GPIO29
+	ENABLE_3V3	Pin	= GPIO10
+
+	BATTERY		= VBAT_SENSE
+	RTC_ALARM	= GPIO8
+)
+```
+
+
+
+```go
+const (
+	I2C0_SDA_PIN	Pin	= GPIO4
+	I2C0_SCL_PIN	Pin	= GPIO5
+
+	I2C1_SDA_PIN	Pin	= NoPin
+	I2C1_SCL_PIN	Pin	= NoPin
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	Pin	= GPIO18
+	SPI0_SDO_PIN	Pin	= GPIO19
+	SPI0_SDI_PIN	Pin	= GPIO16
+
+	SPI1_SCK_PIN	Pin	= NoPin
+	SPI1_SDO_PIN	Pin	= NoPin
+	SPI1_SDI_PIN	Pin	= NoPin
+)
+```
+
+SPI pins.
+
+
+```go
+const (
+	UART0_TX_PIN	= GPIO0
+	UART0_RX_PIN	= GPIO1
+	UART_TX_PIN	= UART0_TX_PIN
+	UART_RX_PIN	= UART0_RX_PIN
+)
+```
+
+UART pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	LS_SE0	= 0b00
+	LS_J	= 0b01
+	LS_K	= 0b10
+	LS_SE1	= 0b11
+)
+```
+
+
+
+```go
+const (
+	cpuFreq			= 200 * MHz
+	_NUMBANK0_GPIOS		= 30
+	_NUMBANK0_IRQS		= 4
+	_NUMIRQ			= 32
+	rp2350ExtraReg		= 0
+	RESETS_RESET_Msk	= 0x01ffffff
+	initUnreset		= rp.RESETS_RESET_ADC |
+		rp.RESETS_RESET_RTC |
+		rp.RESETS_RESET_SPI0 |
+		rp.RESETS_RESET_SPI1 |
+		rp.RESETS_RESET_UART0 |
+		rp.RESETS_RESET_UART1 |
+		rp.RESETS_RESET_USBCTRL
+	initDontReset	= rp.RESETS_RESET_IO_QSPI |
+		rp.RESETS_RESET_PADS_QSPI |
+		rp.RESETS_RESET_PLL_USB |
+		rp.RESETS_RESET_USBCTRL |
+		rp.RESETS_RESET_SYSCFG |
+		rp.RESETS_RESET_PLL_SYS
+	padEnableMask	= rp.PADS_BANK0_GPIO0_IE_Msk |
+		rp.PADS_BANK0_GPIO0_OD_Msk
+)
+```
+
+
+
+```go
+const (
+	PinOutput	PinMode	= iota
+	PinInput
+	PinInputPulldown
+	PinInputPullup
+	PinAnalog
+	PinUART
+	PinPWM
+	PinI2C
+	PinSPI
+	PinPIO0
+	PinPIO1
+)
+```
+
+
+
+```go
+const (
+	ADC0	Pin	= GPIO26
+	ADC1	Pin	= GPIO27
+	ADC2	Pin	= GPIO28
+	ADC3	Pin	= GPIO29
+
+	thermADC	= 30
+)
+```
+
+Analog pins on RP2040.
+
+
+```go
+const (
+	// Edge falling
+	PinFalling	PinChange	= 4 << iota
+	// Edge rising
+	PinRising
+
+	PinToggle	= PinFalling | PinRising
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// GPIO pins
+	GPIO0	Pin	= 0	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO1	Pin	= 1	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO2	Pin	= 2	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO3	Pin	= 3	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO4	Pin	= 4	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO5	Pin	= 5	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO6	Pin	= 6	// peripherals: PWM3 channel A, I2C1 SDA
+	GPIO7	Pin	= 7	// peripherals: PWM3 channel B, I2C1 SCL
+	GPIO8	Pin	= 8	// peripherals: PWM4 channel A, I2C0 SDA
+	GPIO9	Pin	= 9	// peripherals: PWM4 channel B, I2C0 SCL
+	GPIO10	Pin	= 10	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO11	Pin	= 11	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO12	Pin	= 12	// peripherals: PWM6 channel A, I2C0 SDA
+	GPIO13	Pin	= 13	// peripherals: PWM6 channel B, I2C0 SCL
+	GPIO14	Pin	= 14	// peripherals: PWM7 channel A, I2C1 SDA
+	GPIO15	Pin	= 15	// peripherals: PWM7 channel B, I2C1 SCL
+	GPIO16	Pin	= 16	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO17	Pin	= 17	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO18	Pin	= 18	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO19	Pin	= 19	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO20	Pin	= 20	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO21	Pin	= 21	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO22	Pin	= 22	// peripherals: PWM3 channel A
+	GPIO23	Pin	= 23	// peripherals: PWM3 channel B
+	GPIO24	Pin	= 24	// peripherals: PWM4 channel A
+	GPIO25	Pin	= 25	// peripherals: PWM4 channel B
+	GPIO26	Pin	= 26	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO27	Pin	= 27	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO28	Pin	= 28	// peripherals: PWM6 channel A
+	GPIO29	Pin	= 29	// peripherals: PWM6 channel B
+)
+```
+
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 8.3s).
+	//
+	// Nominal 1us per watchdog tick, 24-bit counter,
+	// but due to errata two ticks consumed per 1us.
+	// See: Errata RP2040-E1
+	WatchdogMaxTimeout = (rp.WATCHDOG_LOAD_LOAD_Msk / 1000) / 2
+)
+```
+
+
+
+```go
+const XOSC_STARTUP_DELAY_MULTIPLIER = 64
+```
+
+On some boards, the XOSC can take longer than usual to stabilize. On such
+boards, this is needed to avoid a hard fault on boot/reset. Refer to
+PICO_XOSC_STARTUP_DELAY_MULTIPLIER in the Pico SDK for additional details.
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	UART0	= &_UART0
+	_UART0	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART0,
+	}
+
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART1,
+	}
+)
+```
+
+UART on the RP2040
+
+
+```go
+var RTC = (*rtcType)(unsafe.Pointer(rp.RTC))
+```
+
+
+
+```go
+var (
+	ErrRtcDelayTooSmall	= errors.New("RTC interrupt deplay is too small, shall be at least 1 second")
+	ErrRtcDelayTooLarge	= errors.New("RTC interrupt deplay is too large, shall be no more than 1 day")
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	I2C0	= &_I2C0
+	_I2C0	= I2C{
+		Bus: rp.I2C0,
+	}
+	I2C1	= &_I2C1
+	_I2C1	= I2C{
+		Bus: rp.I2C1,
+	}
+)
+```
+
+I2C on the RP2040/RP2350
+
+
+```go
+var (
+	ErrBadPeriod = errors.New("period outside valid range 8ns..268ms")
+)
+```
+
+
+
+```go
+var (
+	PWM0	= getPWMGroup(0)
+	PWM1	= getPWMGroup(1)
+	PWM2	= getPWMGroup(2)
+	PWM3	= getPWMGroup(3)
+	PWM4	= getPWMGroup(4)
+	PWM5	= getPWMGroup(5)
+	PWM6	= getPWMGroup(6)
+	PWM7	= getPWMGroup(7)
+)
+```
+
+Hardware Pulse Width Modulation (PWM) API
+PWM peripherals available on RP2040. Each peripheral has 2 pins available for
+a total of 16 available PWM outputs. Some pins may not be available on some boards.
+
+The RP2040 PWM block has 8 identical slices. Each slice can drive two PWM output signals, or
+measure the frequency or duty cycle of an input signal. This gives a total of up to 16 controllable
+PWM outputs. All 30 GPIOs can be driven by the PWM block
+
+The PWM hardware functions by continuously comparing the input value to a free-running counter. This produces a
+toggling output where the amount of time spent at the high output level is proportional to the input value. The fraction of
+time spent at the high signal level is known as the duty cycle of the signal.
+
+The default behaviour of a PWM slice is to count upward until the wrap value (\ref pwm_config_set_wrap) is reached, and then
+immediately wrap to 0. PWM slices also offer a phase-correct mode, where the counter starts to count downward after
+reaching TOP, until it reaches 0 again.
+
+
+```go
+var (
+	SPI0	= &SPI{
+		Bus: rp.SPI0,
+	}
+	SPI1	= &SPI{
+		Bus: rp.SPI1,
+	}
+)
+```
+
+SPI on the RP2040
+
+
+```go
+var (
+	ErrLSBNotSupported	= errors.New("SPI LSB unsupported on PL022")
+	ErrSPITimeout		= errors.New("SPI timeout")
+	ErrSPIBaud		= errors.New("SPI baud too low or above 66.5Mhz")
+	errSPIInvalidSDI	= errors.New("invalid SPI SDI pin")
+	errSPIInvalidSDO	= errors.New("invalid SPI SDO pin")
+	errSPIInvalidSCK	= errors.New("invalid SPI SCK pin")
+)
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the RP2040.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ChipVersion
+
+```go
+func ChipVersion() uint8
+```
+
+ChipVersion returns the version of the chip. 1 is returned for B0 and B1
+chip.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func CurrentCore
+
+```go
+func CurrentCore() int
+```
+
+CurrentCore returns the core number the call was made from.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of semi-random data based on ring oscillator.
+
+Unlike some other implementations of GetRNG, these random numbers are not
+cryptographically secure and must not be used for cryptographic operations
+(nonces, etc).
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC resets the ADC peripheral.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func NumCores
+
+```go
+func NumCores() int
+```
+
+NumCores returns number of cores available on the device.
+
+
+### func PWMPeripheral
+
+```go
+func PWMPeripheral(pin Pin) (sliceNum uint8, err error)
+```
+
+Peripheral returns the RP2040 PWM peripheral which ranges from 0 to 7. Each
+PWM peripheral has 2 channels, A and B which correspond to 0 and 1 in the program.
+This number corresponds to the package's PWM0 throughout PWM7 handles
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() (millicelsius int32)
+```
+
+ReadTemperature does a one-shot sample of the internal temperature sensor and returns a milli-celsius reading.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig) error
+```
+
+Configure sets the ADC pin to analog input mode.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns a one-shot ADC sample reading.
+
+
+### func (ADC) GetADCChannel
+
+```go
+func (a ADC) GetADCChannel() (c ADCChannel, err error)
+```
+
+GetADCChannel returns the channel associated with the ADC pin.
+
+
+
+
+## type ADCChannel
+
+```go
+type ADCChannel uint8
+```
+
+ADCChannel is the ADC peripheral mux channel. 0-4.
+
+
+
+### func (ADCChannel) Configure
+
+```go
+func (c ADCChannel) Configure(config ADCConfig) error
+```
+
+Configure sets the channel's associated pin to analog input mode.
+The powered on temperature sensor increases ADC_AVDD current by approximately 40 μA.
+
+
+### func (ADCChannel) Pin
+
+```go
+func (c ADCChannel) Pin() (p Pin, err error)
+```
+
+The Pin method returns the GPIO Pin associated with the ADC mux channel, if it has one.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*rp.I2C0_Type
+	mode		I2CMode
+	txInProgress	bool
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure initializes i2c peripheral and configures I2C config's pins passed.
+Here's a list of valid SDA and SCL GPIO pins on bus I2C0 of the rp2040:
+
+	SDA: 0, 4, 8, 12, 16, 20
+	SCL: 1, 5, 9, 13, 17, 21
+
+Same as above for I2C1 bus:
+
+	SDA: 2, 6, 10, 14, 18, 26
+	SCL: 3, 7, 11, 15, 19, 27
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint16) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx performs a write and then a read transfer placing the result in
+in r.
+
+Passing a nil value for w or r skips the transfer corresponding to write
+or read, respectively.
+
+	i2c.Tx(addr, nil, r)
+
+Performs only a read transfer.
+
+	i2c.Tx(addr, w, nil)
+
+Performs only a write transfer.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	// SDA/SCL Serial Data and clock pins. Refer to datasheet to see
+	// which pins match the desired bus.
+	SDA, SCL	Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure configures the gpio pin as per mode.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get reads the pin value.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set drives the pin high if value is true else drives it low.
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+PinChange represents one or more trigger events that can happen on a given GPIO pin
+on the RP2040. ORed PinChanges are valid input to most IRQ functions.
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus *rp.SPI0_Type
+}
+```
+
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup/initialize the SPI interface.
+Default baudrate of 4MHz is used if Frequency == 0. Default
+word length (data bits) is 8.
+Below is a list of GPIO pins corresponding to SPI0 bus on the rp2040:
+
+	SI : 0, 4, 17  a.k.a RX and MISO (if rp2040 is master)
+	SO : 3, 7, 19  a.k.a TX and MOSI (if rp2040 is master)
+	SCK: 2, 6, 18
+
+SPI1 bus GPIO pins:
+
+	SI : 8, 12
+	SO : 11, 15
+	SCK: 10, 14
+
+No pin configuration is needed of SCK, SDO and SDI needed after calling Configure.
+
+
+### func (*SPI) GetBaudRate
+
+```go
+func (spi *SPI) GetBaudRate() uint32
+```
+
+
+
+### func (*SPI) PrintRegs
+
+```go
+func (spi *SPI) PrintRegs()
+```
+
+PrintRegs prints SPI's peripheral common registries current values
+
+
+### func (*SPI) SetBaudRate
+
+```go
+func (spi *SPI) SetBaudRate(br uint32) error
+```
+
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Write a single byte and read a single byte from TX/RX FIFO.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) (err error)
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+Remark: This implementation (RP2040) allows reading into buffer with a custom repeated
+value on tx.
+
+	spi.Tx([]byte{0xff}, rx) // may cause unwanted heap allocations.
+
+This form sends 0xff and puts the result into rx buffer. Useful for reading from SD cards
+which require 0xff input on SI.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	// LSB not supported on rp2040.
+	LSBFirst	bool
+	// Mode's two most LSB are CPOL and CPHA. i.e. Mode==2 (0b10) is CPOL=1, CPHA=0
+	Mode	uint8
+	// Serial clock pin
+	SCK	Pin
+	// TX or Serial Data Out (MOSI if rp2040 is master)
+	SDO	Pin
+	// RX or Serial Data In (MISO if rp2040 is master)
+	SDI	Pin
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*rp.UART0_Type
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the RP2040.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the baudrate to be used for the UART.
+
+
+### func (*UART) SetFormat
+
+```go
+func (uart *UART) SetFormat(databits, stopbits uint8, parity UARTParity) error
+```
+
+SetFormat for number of data bits, stop bits, and parity for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) ClearStallEPIn
+
+```go
+func (dev *USBDevice) ClearStallEPIn(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB IN endpoint.
+
+
+### func (*USBDevice) ClearStallEPOut
+
+```go
+func (dev *USBDevice) ClearStallEPOut(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB OUT endpoint.
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+### func (*USBDevice) SetStallEPIn
+
+```go
+func (dev *USBDevice) SetStallEPIn(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB IN endpoint.
+
+
+### func (*USBDevice) SetStallEPOut
+
+```go
+func (dev *USBDevice) SetStallEPOut(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB OUT endpoint.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/badger2040.md b/content/docs/reference/microcontrollers/machine/badger2040.md
new file mode 100644
index 00000000..11c96302
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/badger2040.md
@@ -0,0 +1,1671 @@
+
+---
+title: badger2040
+---
+
+
+## Constants
+
+```go
+const (
+	LED	Pin	= GPIO25
+
+	BUTTON_A	Pin	= GPIO12
+	BUTTON_B	Pin	= GPIO13
+	BUTTON_C	Pin	= GPIO14
+	BUTTON_UP	Pin	= GPIO15
+	BUTTON_DOWN	Pin	= GPIO11
+	BUTTON_USER	Pin	= GPIO23
+
+	EPD_BUSY_PIN	Pin	= GPIO26
+	EPD_RESET_PIN	Pin	= GPIO21
+	EPD_DC_PIN	Pin	= GPIO20
+	EPD_CS_PIN	Pin	= GPIO17
+	EPD_SCK_PIN	Pin	= GPIO18
+	EPD_SDO_PIN	Pin	= GPIO19
+
+	VBUS_DETECT	Pin	= GPIO24
+	VREF_POWER	Pin	= GPIO27
+	VREF_1V24	Pin	= GPIO28
+	VBAT_SENSE	Pin	= GPIO29
+	ENABLE_3V3	Pin	= GPIO10
+
+	BATTERY	= VBAT_SENSE
+)
+```
+
+
+
+```go
+const (
+	I2C0_SDA_PIN	Pin	= GPIO4
+	I2C0_SCL_PIN	Pin	= GPIO5
+
+	I2C1_SDA_PIN	Pin	= NoPin
+	I2C1_SCL_PIN	Pin	= NoPin
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	Pin	= GPIO18
+	SPI0_SDO_PIN	Pin	= GPIO19
+	SPI0_SDI_PIN	Pin	= GPIO16
+
+	SPI1_SCK_PIN	Pin	= NoPin
+	SPI1_SDO_PIN	Pin	= NoPin
+	SPI1_SDI_PIN	Pin	= NoPin
+)
+```
+
+SPI pins.
+
+
+```go
+const (
+	UART0_TX_PIN	= GPIO0
+	UART0_RX_PIN	= GPIO1
+	UART_TX_PIN	= UART0_TX_PIN
+	UART_RX_PIN	= UART0_RX_PIN
+)
+```
+
+UART pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	LS_SE0	= 0b00
+	LS_J	= 0b01
+	LS_K	= 0b10
+	LS_SE1	= 0b11
+)
+```
+
+
+
+```go
+const (
+	cpuFreq			= 200 * MHz
+	_NUMBANK0_GPIOS		= 30
+	_NUMBANK0_IRQS		= 4
+	_NUMIRQ			= 32
+	rp2350ExtraReg		= 0
+	RESETS_RESET_Msk	= 0x01ffffff
+	initUnreset		= rp.RESETS_RESET_ADC |
+		rp.RESETS_RESET_RTC |
+		rp.RESETS_RESET_SPI0 |
+		rp.RESETS_RESET_SPI1 |
+		rp.RESETS_RESET_UART0 |
+		rp.RESETS_RESET_UART1 |
+		rp.RESETS_RESET_USBCTRL
+	initDontReset	= rp.RESETS_RESET_IO_QSPI |
+		rp.RESETS_RESET_PADS_QSPI |
+		rp.RESETS_RESET_PLL_USB |
+		rp.RESETS_RESET_USBCTRL |
+		rp.RESETS_RESET_SYSCFG |
+		rp.RESETS_RESET_PLL_SYS
+	padEnableMask	= rp.PADS_BANK0_GPIO0_IE_Msk |
+		rp.PADS_BANK0_GPIO0_OD_Msk
+)
+```
+
+
+
+```go
+const (
+	PinOutput	PinMode	= iota
+	PinInput
+	PinInputPulldown
+	PinInputPullup
+	PinAnalog
+	PinUART
+	PinPWM
+	PinI2C
+	PinSPI
+	PinPIO0
+	PinPIO1
+)
+```
+
+
+
+```go
+const (
+	ADC0	Pin	= GPIO26
+	ADC1	Pin	= GPIO27
+	ADC2	Pin	= GPIO28
+	ADC3	Pin	= GPIO29
+
+	thermADC	= 30
+)
+```
+
+Analog pins on RP2040.
+
+
+```go
+const (
+	// Edge falling
+	PinFalling	PinChange	= 4 << iota
+	// Edge rising
+	PinRising
+
+	PinToggle	= PinFalling | PinRising
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// GPIO pins
+	GPIO0	Pin	= 0	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO1	Pin	= 1	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO2	Pin	= 2	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO3	Pin	= 3	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO4	Pin	= 4	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO5	Pin	= 5	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO6	Pin	= 6	// peripherals: PWM3 channel A, I2C1 SDA
+	GPIO7	Pin	= 7	// peripherals: PWM3 channel B, I2C1 SCL
+	GPIO8	Pin	= 8	// peripherals: PWM4 channel A, I2C0 SDA
+	GPIO9	Pin	= 9	// peripherals: PWM4 channel B, I2C0 SCL
+	GPIO10	Pin	= 10	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO11	Pin	= 11	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO12	Pin	= 12	// peripherals: PWM6 channel A, I2C0 SDA
+	GPIO13	Pin	= 13	// peripherals: PWM6 channel B, I2C0 SCL
+	GPIO14	Pin	= 14	// peripherals: PWM7 channel A, I2C1 SDA
+	GPIO15	Pin	= 15	// peripherals: PWM7 channel B, I2C1 SCL
+	GPIO16	Pin	= 16	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO17	Pin	= 17	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO18	Pin	= 18	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO19	Pin	= 19	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO20	Pin	= 20	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO21	Pin	= 21	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO22	Pin	= 22	// peripherals: PWM3 channel A
+	GPIO23	Pin	= 23	// peripherals: PWM3 channel B
+	GPIO24	Pin	= 24	// peripherals: PWM4 channel A
+	GPIO25	Pin	= 25	// peripherals: PWM4 channel B
+	GPIO26	Pin	= 26	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO27	Pin	= 27	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO28	Pin	= 28	// peripherals: PWM6 channel A
+	GPIO29	Pin	= 29	// peripherals: PWM6 channel B
+)
+```
+
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 8.3s).
+	//
+	// Nominal 1us per watchdog tick, 24-bit counter,
+	// but due to errata two ticks consumed per 1us.
+	// See: Errata RP2040-E1
+	WatchdogMaxTimeout = (rp.WATCHDOG_LOAD_LOAD_Msk / 1000) / 2
+)
+```
+
+
+
+```go
+const XOSC_STARTUP_DELAY_MULTIPLIER = 64
+```
+
+On some boards, the XOSC can take longer than usual to stabilize. On such
+boards, this is needed to avoid a hard fault on boot/reset. Refer to
+PICO_XOSC_STARTUP_DELAY_MULTIPLIER in the Pico SDK for additional details.
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	UART0	= &_UART0
+	_UART0	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART0,
+	}
+
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART1,
+	}
+)
+```
+
+UART on the RP2040
+
+
+```go
+var RTC = (*rtcType)(unsafe.Pointer(rp.RTC))
+```
+
+
+
+```go
+var (
+	ErrRtcDelayTooSmall	= errors.New("RTC interrupt deplay is too small, shall be at least 1 second")
+	ErrRtcDelayTooLarge	= errors.New("RTC interrupt deplay is too large, shall be no more than 1 day")
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	I2C0	= &_I2C0
+	_I2C0	= I2C{
+		Bus: rp.I2C0,
+	}
+	I2C1	= &_I2C1
+	_I2C1	= I2C{
+		Bus: rp.I2C1,
+	}
+)
+```
+
+I2C on the RP2040/RP2350
+
+
+```go
+var (
+	ErrBadPeriod = errors.New("period outside valid range 8ns..268ms")
+)
+```
+
+
+
+```go
+var (
+	PWM0	= getPWMGroup(0)
+	PWM1	= getPWMGroup(1)
+	PWM2	= getPWMGroup(2)
+	PWM3	= getPWMGroup(3)
+	PWM4	= getPWMGroup(4)
+	PWM5	= getPWMGroup(5)
+	PWM6	= getPWMGroup(6)
+	PWM7	= getPWMGroup(7)
+)
+```
+
+Hardware Pulse Width Modulation (PWM) API
+PWM peripherals available on RP2040. Each peripheral has 2 pins available for
+a total of 16 available PWM outputs. Some pins may not be available on some boards.
+
+The RP2040 PWM block has 8 identical slices. Each slice can drive two PWM output signals, or
+measure the frequency or duty cycle of an input signal. This gives a total of up to 16 controllable
+PWM outputs. All 30 GPIOs can be driven by the PWM block
+
+The PWM hardware functions by continuously comparing the input value to a free-running counter. This produces a
+toggling output where the amount of time spent at the high output level is proportional to the input value. The fraction of
+time spent at the high signal level is known as the duty cycle of the signal.
+
+The default behaviour of a PWM slice is to count upward until the wrap value (\ref pwm_config_set_wrap) is reached, and then
+immediately wrap to 0. PWM slices also offer a phase-correct mode, where the counter starts to count downward after
+reaching TOP, until it reaches 0 again.
+
+
+```go
+var (
+	SPI0	= &SPI{
+		Bus: rp.SPI0,
+	}
+	SPI1	= &SPI{
+		Bus: rp.SPI1,
+	}
+)
+```
+
+SPI on the RP2040
+
+
+```go
+var (
+	ErrLSBNotSupported	= errors.New("SPI LSB unsupported on PL022")
+	ErrSPITimeout		= errors.New("SPI timeout")
+	ErrSPIBaud		= errors.New("SPI baud too low or above 66.5Mhz")
+	errSPIInvalidSDI	= errors.New("invalid SPI SDI pin")
+	errSPIInvalidSDO	= errors.New("invalid SPI SDO pin")
+	errSPIInvalidSCK	= errors.New("invalid SPI SCK pin")
+)
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the RP2040.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ChipVersion
+
+```go
+func ChipVersion() uint8
+```
+
+ChipVersion returns the version of the chip. 1 is returned for B0 and B1
+chip.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func CurrentCore
+
+```go
+func CurrentCore() int
+```
+
+CurrentCore returns the core number the call was made from.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of semi-random data based on ring oscillator.
+
+Unlike some other implementations of GetRNG, these random numbers are not
+cryptographically secure and must not be used for cryptographic operations
+(nonces, etc).
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC resets the ADC peripheral.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func NumCores
+
+```go
+func NumCores() int
+```
+
+NumCores returns number of cores available on the device.
+
+
+### func PWMPeripheral
+
+```go
+func PWMPeripheral(pin Pin) (sliceNum uint8, err error)
+```
+
+Peripheral returns the RP2040 PWM peripheral which ranges from 0 to 7. Each
+PWM peripheral has 2 channels, A and B which correspond to 0 and 1 in the program.
+This number corresponds to the package's PWM0 throughout PWM7 handles
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() (millicelsius int32)
+```
+
+ReadTemperature does a one-shot sample of the internal temperature sensor and returns a milli-celsius reading.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig) error
+```
+
+Configure sets the ADC pin to analog input mode.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns a one-shot ADC sample reading.
+
+
+### func (ADC) GetADCChannel
+
+```go
+func (a ADC) GetADCChannel() (c ADCChannel, err error)
+```
+
+GetADCChannel returns the channel associated with the ADC pin.
+
+
+
+
+## type ADCChannel
+
+```go
+type ADCChannel uint8
+```
+
+ADCChannel is the ADC peripheral mux channel. 0-4.
+
+
+
+### func (ADCChannel) Configure
+
+```go
+func (c ADCChannel) Configure(config ADCConfig) error
+```
+
+Configure sets the channel's associated pin to analog input mode.
+The powered on temperature sensor increases ADC_AVDD current by approximately 40 μA.
+
+
+### func (ADCChannel) Pin
+
+```go
+func (c ADCChannel) Pin() (p Pin, err error)
+```
+
+The Pin method returns the GPIO Pin associated with the ADC mux channel, if it has one.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*rp.I2C0_Type
+	mode		I2CMode
+	txInProgress	bool
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure initializes i2c peripheral and configures I2C config's pins passed.
+Here's a list of valid SDA and SCL GPIO pins on bus I2C0 of the rp2040:
+
+	SDA: 0, 4, 8, 12, 16, 20
+	SCL: 1, 5, 9, 13, 17, 21
+
+Same as above for I2C1 bus:
+
+	SDA: 2, 6, 10, 14, 18, 26
+	SCL: 3, 7, 11, 15, 19, 27
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint16) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx performs a write and then a read transfer placing the result in
+in r.
+
+Passing a nil value for w or r skips the transfer corresponding to write
+or read, respectively.
+
+	i2c.Tx(addr, nil, r)
+
+Performs only a read transfer.
+
+	i2c.Tx(addr, w, nil)
+
+Performs only a write transfer.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	// SDA/SCL Serial Data and clock pins. Refer to datasheet to see
+	// which pins match the desired bus.
+	SDA, SCL	Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure configures the gpio pin as per mode.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get reads the pin value.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set drives the pin high if value is true else drives it low.
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+PinChange represents one or more trigger events that can happen on a given GPIO pin
+on the RP2040. ORed PinChanges are valid input to most IRQ functions.
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus *rp.SPI0_Type
+}
+```
+
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup/initialize the SPI interface.
+Default baudrate of 4MHz is used if Frequency == 0. Default
+word length (data bits) is 8.
+Below is a list of GPIO pins corresponding to SPI0 bus on the rp2040:
+
+	SI : 0, 4, 17  a.k.a RX and MISO (if rp2040 is master)
+	SO : 3, 7, 19  a.k.a TX and MOSI (if rp2040 is master)
+	SCK: 2, 6, 18
+
+SPI1 bus GPIO pins:
+
+	SI : 8, 12
+	SO : 11, 15
+	SCK: 10, 14
+
+No pin configuration is needed of SCK, SDO and SDI needed after calling Configure.
+
+
+### func (*SPI) GetBaudRate
+
+```go
+func (spi *SPI) GetBaudRate() uint32
+```
+
+
+
+### func (*SPI) PrintRegs
+
+```go
+func (spi *SPI) PrintRegs()
+```
+
+PrintRegs prints SPI's peripheral common registries current values
+
+
+### func (*SPI) SetBaudRate
+
+```go
+func (spi *SPI) SetBaudRate(br uint32) error
+```
+
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Write a single byte and read a single byte from TX/RX FIFO.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) (err error)
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+Remark: This implementation (RP2040) allows reading into buffer with a custom repeated
+value on tx.
+
+	spi.Tx([]byte{0xff}, rx) // may cause unwanted heap allocations.
+
+This form sends 0xff and puts the result into rx buffer. Useful for reading from SD cards
+which require 0xff input on SI.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	// LSB not supported on rp2040.
+	LSBFirst	bool
+	// Mode's two most LSB are CPOL and CPHA. i.e. Mode==2 (0b10) is CPOL=1, CPHA=0
+	Mode	uint8
+	// Serial clock pin
+	SCK	Pin
+	// TX or Serial Data Out (MOSI if rp2040 is master)
+	SDO	Pin
+	// RX or Serial Data In (MISO if rp2040 is master)
+	SDI	Pin
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*rp.UART0_Type
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the RP2040.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the baudrate to be used for the UART.
+
+
+### func (*UART) SetFormat
+
+```go
+func (uart *UART) SetFormat(databits, stopbits uint8, parity UARTParity) error
+```
+
+SetFormat for number of data bits, stop bits, and parity for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) ClearStallEPIn
+
+```go
+func (dev *USBDevice) ClearStallEPIn(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB IN endpoint.
+
+
+### func (*USBDevice) ClearStallEPOut
+
+```go
+func (dev *USBDevice) ClearStallEPOut(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB OUT endpoint.
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+### func (*USBDevice) SetStallEPIn
+
+```go
+func (dev *USBDevice) SetStallEPIn(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB IN endpoint.
+
+
+### func (*USBDevice) SetStallEPOut
+
+```go
+func (dev *USBDevice) SetStallEPOut(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB OUT endpoint.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/bluepill.md b/content/docs/reference/microcontrollers/machine/bluepill.md
new file mode 100644
index 00000000..c7000db6
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/bluepill.md
@@ -0,0 +1,1655 @@
+
+---
+title: bluepill
+---
+
+
+## Constants
+
+```go
+const (
+	C13	= PC13
+	C14	= PC14
+	C15	= PC15
+	A0	= PA0
+	A1	= PA1
+	A2	= PA2
+	A3	= PA3
+	A4	= PA4
+	A5	= PA5
+	A6	= PA6
+	A7	= PA7
+	B0	= PB0
+	B1	= PB1
+	B10	= PB10
+	B11	= PB11
+	B12	= PB12
+	B13	= PB13
+	B14	= PB14
+	B15	= PB15
+	A8	= PA8
+	A9	= PA9
+	A10	= PA10
+	A11	= PA11
+	A12	= PA12
+	A13	= PA13
+	A14	= PA14
+	A15	= PA15
+	B3	= PB3
+	B4	= PB4
+	B5	= PB5
+	B6	= PB6
+	B7	= PB7
+	B8	= PB8
+	B9	= PB9
+)
+```
+
+Pins printed on the silkscreen
+
+
+```go
+const (
+	ADC0	= PA0
+	ADC1	= PA1
+	ADC2	= PA2
+	ADC3	= PA3
+	ADC4	= PA4
+	ADC5	= PA5
+	ADC6	= PA6
+	ADC7	= PA7
+	ADC8	= PB0
+	ADC9	= PB1
+)
+```
+
+Analog Pins
+
+
+```go
+const (
+	// This board does not have a user button, so
+	// use first GPIO pin by default
+	BUTTON	= PA0
+
+	LED	= PC13
+)
+```
+
+
+
+```go
+const (
+	UART_TX_PIN	= PA9
+	UART_RX_PIN	= PA10
+	UART_ALT_TX_PIN	= PB6
+	UART_ALT_RX_PIN	= PB7
+)
+```
+
+UART pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= PA5
+	SPI0_SDO_PIN	= PA7
+	SPI0_SDI_PIN	= PA6
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	I2C0_SDA_PIN	= PB7
+	I2C0_SCL_PIN	= PB6
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinRising	PinChange	= 1 << iota
+	PinFalling
+	PinToggle	= PinRising | PinFalling
+)
+```
+
+
+
+```go
+const (
+	Cycles_1_5	= 0x0
+	Cycles_7_5	= 0x1
+	Cycles_13_5	= 0x2
+	Cycles_28_5	= 0x3
+	Cycles_41_5	= 0x4
+	Cycles_55_5	= 0x5
+	Cycles_71_5	= 0x6
+	Cycles_239_5	= 0x7
+)
+```
+
+
+
+```go
+const (
+	DutyCycle2	= 0
+	DutyCycle16x9	= 1
+)
+```
+
+I2C fast mode (Fm) duty cycle
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (32.768s)
+	//
+	// Timeout is based on 12-bit counter with /256 divider on
+	// 32.768kHz clock.  See 21.3.3 of RM0090 for table.
+	WatchdogMaxTimeout = ((0xfff + 1) * 256 * 1024) / 32768
+)
+```
+
+
+
+```go
+const PWM_MODE1 = 0x6
+```
+
+
+
+```go
+const APB1_TIM_FREQ = 72e6	// 72MHz
+
+```
+
+Internal use: configured speed of the APB1 and APB2 timers, this should be kept
+in sync with any changes to runtime package which configures the oscillators
+and clock frequencies
+
+
+```go
+const APB2_TIM_FREQ = 72e6	// 72MHz
+
+```
+
+
+
+```go
+const (
+	PinInput	PinMode	= 0	// Input mode
+	PinOutput10MHz	PinMode	= 1	// Output mode, max speed 10MHz
+	PinOutput2MHz	PinMode	= 2	// Output mode, max speed 2MHz
+	PinOutput50MHz	PinMode	= 3	// Output mode, max speed 50MHz
+	PinOutput	PinMode	= PinOutput2MHz
+
+	PinInputModeAnalog	PinMode	= 0	// Input analog mode
+	PinInputModeFloating	PinMode	= 4	// Input floating mode
+	PinInputModePullUpDown	PinMode	= 8	// Input pull up/down mode
+	PinInputModeReserved	PinMode	= 12	// Input mode (reserved)
+
+	PinOutputModeGPPushPull		PinMode	= 0	// Output mode general purpose push/pull
+	PinOutputModeGPOpenDrain	PinMode	= 4	// Output mode general purpose open drain
+	PinOutputModeAltPushPull	PinMode	= 8	// Output mode alt. purpose push/pull
+	PinOutputModeAltOpenDrain	PinMode	= 12	// Output mode alt. purpose open drain
+
+	// Pull-up vs Pull down is not part of the CNF0 / CNF1 bits, but is
+	// controlled by PxODR.  Encoded using the 'spare' bit 5.
+	PinInputPulldown	PinMode	= PinInputModePullUpDown
+	PinInputPullup		PinMode	= PinInputModePullUpDown | 0x10
+)
+```
+
+
+
+```go
+const (
+	PA0	= portA + 0
+	PA1	= portA + 1
+	PA2	= portA + 2
+	PA3	= portA + 3
+	PA4	= portA + 4
+	PA5	= portA + 5
+	PA6	= portA + 6
+	PA7	= portA + 7
+	PA8	= portA + 8
+	PA9	= portA + 9
+	PA10	= portA + 10
+	PA11	= portA + 11
+	PA12	= portA + 12
+	PA13	= portA + 13
+	PA14	= portA + 14
+	PA15	= portA + 15
+
+	PB0	= portB + 0
+	PB1	= portB + 1
+	PB2	= portB + 2
+	PB3	= portB + 3
+	PB4	= portB + 4
+	PB5	= portB + 5
+	PB6	= portB + 6
+	PB7	= portB + 7
+	PB8	= portB + 8
+	PB9	= portB + 9
+	PB10	= portB + 10
+	PB11	= portB + 11
+	PB12	= portB + 12
+	PB13	= portB + 13
+	PB14	= portB + 14
+	PB15	= portB + 15
+
+	PC0	= portC + 0
+	PC1	= portC + 1
+	PC2	= portC + 2
+	PC3	= portC + 3
+	PC4	= portC + 4
+	PC5	= portC + 5
+	PC6	= portC + 6
+	PC7	= portC + 7
+	PC8	= portC + 8
+	PC9	= portC + 9
+	PC10	= portC + 10
+	PC11	= portC + 11
+	PC12	= portC + 12
+	PC13	= portC + 13
+	PC14	= portC + 14
+	PC15	= portC + 15
+
+	PD0	= portD + 0
+	PD1	= portD + 1
+	PD2	= portD + 2
+	PD3	= portD + 3
+	PD4	= portD + 4
+	PD5	= portD + 5
+	PD6	= portD + 6
+	PD7	= portD + 7
+	PD8	= portD + 8
+	PD9	= portD + 9
+	PD10	= portD + 10
+	PD11	= portD + 11
+	PD12	= portD + 12
+	PD13	= portD + 13
+	PD14	= portD + 14
+	PD15	= portD + 15
+
+	PE0	= portE + 0
+	PE1	= portE + 1
+	PE2	= portE + 2
+	PE3	= portE + 3
+	PE4	= portE + 4
+	PE5	= portE + 5
+	PE6	= portE + 6
+	PE7	= portE + 7
+	PE8	= portE + 8
+	PE9	= portE + 9
+	PE10	= portE + 10
+	PE11	= portE + 11
+	PE12	= portE + 12
+	PE13	= portE + 13
+	PE14	= portE + 14
+	PE15	= portE + 15
+
+	PF0	= portF + 0
+	PF1	= portF + 1
+	PF2	= portF + 2
+	PF3	= portF + 3
+	PF4	= portF + 4
+	PF5	= portF + 5
+	PF6	= portF + 6
+	PF7	= portF + 7
+	PF8	= portF + 8
+	PF9	= portF + 9
+	PF10	= portF + 10
+	PF11	= portF + 11
+	PF12	= portF + 12
+	PF13	= portF + 13
+	PF14	= portF + 14
+	PF15	= portF + 15
+)
+```
+
+Pin constants for all stm32f103 package sizes
+
+
+```go
+const (
+	ARR_MAX	= 0x10000
+	PSC_MAX	= 0x10000
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var DefaultUART = UART1
+```
+
+
+
+```go
+var (
+	// USART1 is the first hardware serial port on the STM32.
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	stm32.USART1,
+	}
+	UART2	= &_UART2
+	_UART2	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	stm32.USART2,
+	}
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	SPI1	= &SPI{Bus: stm32.SPI1}
+	SPI0	= SPI1
+)
+```
+
+There are 3 SPI interfaces on the STM32F103xx.
+Since the first interface is named SPI1, both SPI0 and SPI1 refer to SPI1.
+TODO: implement SPI2 and SPI3.
+
+
+```go
+var (
+	I2C1	= &I2C{Bus: stm32.I2C1}
+	I2C0	= I2C1
+)
+```
+
+
+
+```go
+var (
+	TIM1	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM1EN,
+		Device:		stm32.TIM1,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PE9, 0b11}, {PA8, 0b00}}},
+			TimerChannel{Pins: []PinFunction{{PE11, 0b11}, {PA9, 0b00}}},
+			TimerChannel{Pins: []PinFunction{{PE13, 0b11}, {PA10, 0b00}}},
+			TimerChannel{Pins: []PinFunction{{PE14, 0b11}, {PA11, 0b00}}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM2	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM2EN,
+		Device:		stm32.TIM2,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA0, 0b00}, {PA15, 0b01}}},
+			TimerChannel{Pins: []PinFunction{{PA1, 0b00}, {PB3, 0b01}}},
+			TimerChannel{Pins: []PinFunction{{PA2, 0b00}, {PB10, 0b10}}},
+			TimerChannel{Pins: []PinFunction{{PA3, 0b00}, {PB11, 0b10}}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM3	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM3EN,
+		Device:		stm32.TIM3,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA6, 0b00}, {PC6, 0b11}, {PB4, 0b10}}},
+			TimerChannel{Pins: []PinFunction{{PA7, 0b00}, {PC7, 0b11}, {PB5, 0b10}}},
+			TimerChannel{Pins: []PinFunction{{PB0, 0b00}, {PC8, 0b11}}},
+			TimerChannel{Pins: []PinFunction{{PB1, 0b00}, {PC9, 0b11}}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM4	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM4EN,
+		Device:		stm32.TIM4,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PD12, 0b1}, {PB6, 0}}},
+			TimerChannel{Pins: []PinFunction{{PD13, 0b1}, {PB7, 0}}},
+			TimerChannel{Pins: []PinFunction{{PD14, 0b1}, {PB8, 0}}},
+			TimerChannel{Pins: []PinFunction{{PD15, 0b1}, {PB9, 0}}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM5	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM5EN,
+		Device:		stm32.TIM5,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{{PA3, 0b0}}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM6	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM6EN,
+		Device:		stm32.TIM6,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM7	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM7EN,
+		Device:		stm32.TIM7,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM8	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM8EN,
+		Device:		stm32.TIM8,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM9	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM9EN,
+		Device:		stm32.TIM9,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA2, 0b0}, {PE5, 0b1}}},
+			TimerChannel{Pins: []PinFunction{{PA3, 0b0}, {PE6, 0b1}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM10	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM10EN,
+		Device:		stm32.TIM10,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PB8, 0b0}, {PF6, 0b1}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM11	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM11EN,
+		Device:		stm32.TIM11,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PB9, 0b0}, {PF7, 0b1}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM12	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM12EN,
+		Device:		stm32.TIM12,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM13	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM13EN,
+		Device:		stm32.TIM13,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA6, 0b0}, {PF8, 0b1}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM14	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM14EN,
+		Device:		stm32.TIM14,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA7, 0b0}, {PF9, 0b1}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+)
+```
+
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself.
+
+The length of the device ID for STM32 is 12 bytes (96 bits).
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC1.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(ADCConfig)
+```
+
+Configure configures an ADC pin to be able to read analog data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin in the range 0..0xffff.
+TODO: DMA based implementation.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type ChannelCallback
+
+```go
+type ChannelCallback func(channel uint8)
+```
+
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus *stm32.I2C_Type
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the STM32 I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+	DutyCycle	uint8
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given I/O settings.
+stm32f1xx uses different technique for setting the GPIO pins than the stm32f407
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+PortMaskClear returns the register and mask to disable a given port. This can
+be used to implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+PortMaskSet returns the register and mask to enable a given GPIO pin. This
+can be used to implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+---------- General pin operations ----------
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinFunction
+
+```go
+type PinFunction struct {
+	Pin	Pin
+	AltFunc	uint8
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus *stm32.SPI_Type
+}
+```
+
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the STM32 SPI1 interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type TIM
+
+```go
+type TIM struct {
+	EnableRegister	*volatile.Register32
+	EnableFlag	uint32
+	Device		*stm32.TIM_Type
+	Channels	[4]TimerChannel
+	UpInterrupt	interrupt.Interrupt
+	OCInterrupt	interrupt.Interrupt
+
+	wraparoundCallback	TimerCallback
+	channelCallbacks	[4]ChannelCallback
+
+	busFreq	uint64
+}
+```
+
+
+
+
+### func (*TIM) Channel
+
+```go
+func (t *TIM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*TIM) Configure
+
+```go
+func (t *TIM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+
+
+### func (*TIM) Count
+
+```go
+func (t *TIM) Count() uint32
+```
+
+
+
+### func (*TIM) Set
+
+```go
+func (t *TIM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	t.Set(ch, t.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*TIM) SetInverting
+
+```go
+func (t *TIM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TIM) SetMatchInterrupt
+
+```go
+func (t *TIM) SetMatchInterrupt(channel uint8, callback ChannelCallback) error
+```
+
+Sets a callback to be called when a channel reaches it's set-point.
+
+For example, if `t.Set(ch, t.Top() / 4)` is used then the callback will
+be called every quarter-period of the timer's base Period.
+
+
+### func (*TIM) SetPeriod
+
+```go
+func (t *TIM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TIM) SetWraparoundInterrupt
+
+```go
+func (t *TIM) SetWraparoundInterrupt(callback TimerCallback) error
+```
+
+SetWraparoundInterrupt configures a callback to be called each
+time the timer 'wraps-around'.
+
+For example, if `Configure(PWMConfig{Period:1000000})` is used,
+to set the timer period to 1ms, this callback will be called every
+1ms.
+
+
+### func (*TIM) Top
+
+```go
+func (t *TIM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+### func (*TIM) Unset
+
+```go
+func (t *TIM) Unset(channel uint8)
+```
+
+Unset disables a channel, including any configured interrupts.
+
+
+
+
+## type TimerCallback
+
+```go
+type TimerCallback func()
+```
+
+
+
+
+
+
+## type TimerChannel
+
+```go
+type TimerChannel struct {
+	Pins []PinFunction
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer			*RingBuffer
+	Bus			*stm32.USART_Type
+	Interrupt		interrupt.Interrupt
+	TxAltFuncSelector	uint8
+	RxAltFuncSelector	uint8
+
+	// Registers specific to the chip
+	rxReg		*volatile.Register32
+	txReg		*volatile.Register32
+	statusReg	*volatile.Register32
+	txEmptyFlag	uint32
+}
+```
+
+UART representation
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART. Defer to chip-specific
+routines for calculation
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/challenger-rp2040.md b/content/docs/reference/microcontrollers/machine/challenger-rp2040.md
new file mode 100644
index 00000000..d86c4c5e
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/challenger-rp2040.md
@@ -0,0 +1,1706 @@
+
+---
+title: challenger-rp2040
+---
+
+
+## Constants
+
+```go
+const (
+	LED	= GPIO24
+
+	// Onboard crystal oscillator frequency, in MHz.
+	xoscFreq	= 12	// MHz
+)
+```
+
+
+
+```go
+const (
+	D5	= GPIO2
+	D6	= GPIO3
+	D9	= GPIO4
+	D10	= GPIO5
+	D11	= GPIO6
+	D12	= GPIO7
+	D13	= GPIO8
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A0	= ADC0
+	A1	= ADC1
+	A2	= ADC2
+	A3	= ADC3
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	I2C0_SDA_PIN	= GPIO24
+	I2C0_SCL_PIN	= GPIO25
+
+	I2C1_SDA_PIN	= GPIO2
+	I2C1_SCL_PIN	= GPIO3
+
+	SDA_PIN	= I2C1_SDA_PIN
+	SCL_PIN	= I2C1_SCL_PIN
+)
+```
+
+I2C Pins.
+
+
+```go
+const (
+	// Default Serial Clock Bus 0 for SPI communications
+	SPI0_SCK_PIN	= GPIO22
+	// Default Serial Out Bus 0 for SPI communications
+	SPI0_SDO_PIN	= GPIO23	// Tx
+	// Default Serial In Bus 0 for SPI communications
+	SPI0_SDI_PIN	= GPIO20	// Rx
+
+	// Default Serial Clock Bus 1 for SPI communications
+	SPI1_SCK_PIN	= GPIO10
+	// Default Serial Out Bus 1 for SPI communications
+	SPI1_SDO_PIN	= GPIO11	// Tx
+	// Default Serial In Bus 1 for SPI communications
+	SPI1_SDI_PIN	= GPIO12	// Rx
+)
+```
+
+SPI default pins
+
+
+```go
+const (
+	LORA_CS		= GPIO9
+	LORA_SCK	= GPIO10
+	LORA_SDO	= GPIO11
+	LORA_SDI	= GPIO12
+	LORA_RESET	= GPIO13
+	LORA_DIO0	= GPIO14
+	LORA_DIO1	= GPIO15
+	LORA_DIO2	= GPIO18
+)
+```
+
+LoRa default pins
+
+
+```go
+const (
+	UART0_TX_PIN	= GPIO16
+	UART0_RX_PIN	= GPIO17
+	UART1_TX_PIN	= GPIO4
+	UART1_RX_PIN	= GPIO5
+	UART_TX_PIN	= UART0_TX_PIN
+	UART_RX_PIN	= UART0_RX_PIN
+)
+```
+
+UART pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	LS_SE0	= 0b00
+	LS_J	= 0b01
+	LS_K	= 0b10
+	LS_SE1	= 0b11
+)
+```
+
+
+
+```go
+const (
+	cpuFreq			= 200 * MHz
+	_NUMBANK0_GPIOS		= 30
+	_NUMBANK0_IRQS		= 4
+	_NUMIRQ			= 32
+	rp2350ExtraReg		= 0
+	RESETS_RESET_Msk	= 0x01ffffff
+	initUnreset		= rp.RESETS_RESET_ADC |
+		rp.RESETS_RESET_RTC |
+		rp.RESETS_RESET_SPI0 |
+		rp.RESETS_RESET_SPI1 |
+		rp.RESETS_RESET_UART0 |
+		rp.RESETS_RESET_UART1 |
+		rp.RESETS_RESET_USBCTRL
+	initDontReset	= rp.RESETS_RESET_IO_QSPI |
+		rp.RESETS_RESET_PADS_QSPI |
+		rp.RESETS_RESET_PLL_USB |
+		rp.RESETS_RESET_USBCTRL |
+		rp.RESETS_RESET_SYSCFG |
+		rp.RESETS_RESET_PLL_SYS
+	padEnableMask	= rp.PADS_BANK0_GPIO0_IE_Msk |
+		rp.PADS_BANK0_GPIO0_OD_Msk
+)
+```
+
+
+
+```go
+const (
+	PinOutput	PinMode	= iota
+	PinInput
+	PinInputPulldown
+	PinInputPullup
+	PinAnalog
+	PinUART
+	PinPWM
+	PinI2C
+	PinSPI
+	PinPIO0
+	PinPIO1
+)
+```
+
+
+
+```go
+const (
+	ADC0	Pin	= GPIO26
+	ADC1	Pin	= GPIO27
+	ADC2	Pin	= GPIO28
+	ADC3	Pin	= GPIO29
+
+	thermADC	= 30
+)
+```
+
+Analog pins on RP2040.
+
+
+```go
+const (
+	// Edge falling
+	PinFalling	PinChange	= 4 << iota
+	// Edge rising
+	PinRising
+
+	PinToggle	= PinFalling | PinRising
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// GPIO pins
+	GPIO0	Pin	= 0	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO1	Pin	= 1	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO2	Pin	= 2	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO3	Pin	= 3	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO4	Pin	= 4	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO5	Pin	= 5	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO6	Pin	= 6	// peripherals: PWM3 channel A, I2C1 SDA
+	GPIO7	Pin	= 7	// peripherals: PWM3 channel B, I2C1 SCL
+	GPIO8	Pin	= 8	// peripherals: PWM4 channel A, I2C0 SDA
+	GPIO9	Pin	= 9	// peripherals: PWM4 channel B, I2C0 SCL
+	GPIO10	Pin	= 10	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO11	Pin	= 11	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO12	Pin	= 12	// peripherals: PWM6 channel A, I2C0 SDA
+	GPIO13	Pin	= 13	// peripherals: PWM6 channel B, I2C0 SCL
+	GPIO14	Pin	= 14	// peripherals: PWM7 channel A, I2C1 SDA
+	GPIO15	Pin	= 15	// peripherals: PWM7 channel B, I2C1 SCL
+	GPIO16	Pin	= 16	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO17	Pin	= 17	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO18	Pin	= 18	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO19	Pin	= 19	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO20	Pin	= 20	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO21	Pin	= 21	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO22	Pin	= 22	// peripherals: PWM3 channel A
+	GPIO23	Pin	= 23	// peripherals: PWM3 channel B
+	GPIO24	Pin	= 24	// peripherals: PWM4 channel A
+	GPIO25	Pin	= 25	// peripherals: PWM4 channel B
+	GPIO26	Pin	= 26	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO27	Pin	= 27	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO28	Pin	= 28	// peripherals: PWM6 channel A
+	GPIO29	Pin	= 29	// peripherals: PWM6 channel B
+)
+```
+
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 8.3s).
+	//
+	// Nominal 1us per watchdog tick, 24-bit counter,
+	// but due to errata two ticks consumed per 1us.
+	// See: Errata RP2040-E1
+	WatchdogMaxTimeout = (rp.WATCHDOG_LOAD_LOAD_Msk / 1000) / 2
+)
+```
+
+
+
+```go
+const XOSC_STARTUP_DELAY_MULTIPLIER = 64
+```
+
+On some boards, the XOSC can take longer than usual to stabilize. On such
+boards, this is needed to avoid a hard fault on boot/reset. Refer to
+PICO_XOSC_STARTUP_DELAY_MULTIPLIER in the Pico SDK for additional details.
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	UART0	= &_UART0
+	_UART0	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART0,
+	}
+
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART1,
+	}
+)
+```
+
+UART on the RP2040
+
+
+```go
+var RTC = (*rtcType)(unsafe.Pointer(rp.RTC))
+```
+
+
+
+```go
+var (
+	ErrRtcDelayTooSmall	= errors.New("RTC interrupt deplay is too small, shall be at least 1 second")
+	ErrRtcDelayTooLarge	= errors.New("RTC interrupt deplay is too large, shall be no more than 1 day")
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	I2C0	= &_I2C0
+	_I2C0	= I2C{
+		Bus: rp.I2C0,
+	}
+	I2C1	= &_I2C1
+	_I2C1	= I2C{
+		Bus: rp.I2C1,
+	}
+)
+```
+
+I2C on the RP2040/RP2350
+
+
+```go
+var (
+	ErrBadPeriod = errors.New("period outside valid range 8ns..268ms")
+)
+```
+
+
+
+```go
+var (
+	PWM0	= getPWMGroup(0)
+	PWM1	= getPWMGroup(1)
+	PWM2	= getPWMGroup(2)
+	PWM3	= getPWMGroup(3)
+	PWM4	= getPWMGroup(4)
+	PWM5	= getPWMGroup(5)
+	PWM6	= getPWMGroup(6)
+	PWM7	= getPWMGroup(7)
+)
+```
+
+Hardware Pulse Width Modulation (PWM) API
+PWM peripherals available on RP2040. Each peripheral has 2 pins available for
+a total of 16 available PWM outputs. Some pins may not be available on some boards.
+
+The RP2040 PWM block has 8 identical slices. Each slice can drive two PWM output signals, or
+measure the frequency or duty cycle of an input signal. This gives a total of up to 16 controllable
+PWM outputs. All 30 GPIOs can be driven by the PWM block
+
+The PWM hardware functions by continuously comparing the input value to a free-running counter. This produces a
+toggling output where the amount of time spent at the high output level is proportional to the input value. The fraction of
+time spent at the high signal level is known as the duty cycle of the signal.
+
+The default behaviour of a PWM slice is to count upward until the wrap value (\ref pwm_config_set_wrap) is reached, and then
+immediately wrap to 0. PWM slices also offer a phase-correct mode, where the counter starts to count downward after
+reaching TOP, until it reaches 0 again.
+
+
+```go
+var (
+	SPI0	= &SPI{
+		Bus: rp.SPI0,
+	}
+	SPI1	= &SPI{
+		Bus: rp.SPI1,
+	}
+)
+```
+
+SPI on the RP2040
+
+
+```go
+var (
+	ErrLSBNotSupported	= errors.New("SPI LSB unsupported on PL022")
+	ErrSPITimeout		= errors.New("SPI timeout")
+	ErrSPIBaud		= errors.New("SPI baud too low or above 66.5Mhz")
+	errSPIInvalidSDI	= errors.New("invalid SPI SDI pin")
+	errSPIInvalidSDO	= errors.New("invalid SPI SDO pin")
+	errSPIInvalidSCK	= errors.New("invalid SPI SCK pin")
+)
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the RP2040.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ChipVersion
+
+```go
+func ChipVersion() uint8
+```
+
+ChipVersion returns the version of the chip. 1 is returned for B0 and B1
+chip.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func CurrentCore
+
+```go
+func CurrentCore() int
+```
+
+CurrentCore returns the core number the call was made from.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of semi-random data based on ring oscillator.
+
+Unlike some other implementations of GetRNG, these random numbers are not
+cryptographically secure and must not be used for cryptographic operations
+(nonces, etc).
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC resets the ADC peripheral.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func NumCores
+
+```go
+func NumCores() int
+```
+
+NumCores returns number of cores available on the device.
+
+
+### func PWMPeripheral
+
+```go
+func PWMPeripheral(pin Pin) (sliceNum uint8, err error)
+```
+
+Peripheral returns the RP2040 PWM peripheral which ranges from 0 to 7. Each
+PWM peripheral has 2 channels, A and B which correspond to 0 and 1 in the program.
+This number corresponds to the package's PWM0 throughout PWM7 handles
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() (millicelsius int32)
+```
+
+ReadTemperature does a one-shot sample of the internal temperature sensor and returns a milli-celsius reading.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig) error
+```
+
+Configure sets the ADC pin to analog input mode.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns a one-shot ADC sample reading.
+
+
+### func (ADC) GetADCChannel
+
+```go
+func (a ADC) GetADCChannel() (c ADCChannel, err error)
+```
+
+GetADCChannel returns the channel associated with the ADC pin.
+
+
+
+
+## type ADCChannel
+
+```go
+type ADCChannel uint8
+```
+
+ADCChannel is the ADC peripheral mux channel. 0-4.
+
+
+
+### func (ADCChannel) Configure
+
+```go
+func (c ADCChannel) Configure(config ADCConfig) error
+```
+
+Configure sets the channel's associated pin to analog input mode.
+The powered on temperature sensor increases ADC_AVDD current by approximately 40 μA.
+
+
+### func (ADCChannel) Pin
+
+```go
+func (c ADCChannel) Pin() (p Pin, err error)
+```
+
+The Pin method returns the GPIO Pin associated with the ADC mux channel, if it has one.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*rp.I2C0_Type
+	mode		I2CMode
+	txInProgress	bool
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure initializes i2c peripheral and configures I2C config's pins passed.
+Here's a list of valid SDA and SCL GPIO pins on bus I2C0 of the rp2040:
+
+	SDA: 0, 4, 8, 12, 16, 20
+	SCL: 1, 5, 9, 13, 17, 21
+
+Same as above for I2C1 bus:
+
+	SDA: 2, 6, 10, 14, 18, 26
+	SCL: 3, 7, 11, 15, 19, 27
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint16) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx performs a write and then a read transfer placing the result in
+in r.
+
+Passing a nil value for w or r skips the transfer corresponding to write
+or read, respectively.
+
+	i2c.Tx(addr, nil, r)
+
+Performs only a read transfer.
+
+	i2c.Tx(addr, w, nil)
+
+Performs only a write transfer.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	// SDA/SCL Serial Data and clock pins. Refer to datasheet to see
+	// which pins match the desired bus.
+	SDA, SCL	Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure configures the gpio pin as per mode.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get reads the pin value.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set drives the pin high if value is true else drives it low.
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+PinChange represents one or more trigger events that can happen on a given GPIO pin
+on the RP2040. ORed PinChanges are valid input to most IRQ functions.
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus *rp.SPI0_Type
+}
+```
+
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup/initialize the SPI interface.
+Default baudrate of 4MHz is used if Frequency == 0. Default
+word length (data bits) is 8.
+Below is a list of GPIO pins corresponding to SPI0 bus on the rp2040:
+
+	SI : 0, 4, 17  a.k.a RX and MISO (if rp2040 is master)
+	SO : 3, 7, 19  a.k.a TX and MOSI (if rp2040 is master)
+	SCK: 2, 6, 18
+
+SPI1 bus GPIO pins:
+
+	SI : 8, 12
+	SO : 11, 15
+	SCK: 10, 14
+
+No pin configuration is needed of SCK, SDO and SDI needed after calling Configure.
+
+
+### func (*SPI) GetBaudRate
+
+```go
+func (spi *SPI) GetBaudRate() uint32
+```
+
+
+
+### func (*SPI) PrintRegs
+
+```go
+func (spi *SPI) PrintRegs()
+```
+
+PrintRegs prints SPI's peripheral common registries current values
+
+
+### func (*SPI) SetBaudRate
+
+```go
+func (spi *SPI) SetBaudRate(br uint32) error
+```
+
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Write a single byte and read a single byte from TX/RX FIFO.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) (err error)
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+Remark: This implementation (RP2040) allows reading into buffer with a custom repeated
+value on tx.
+
+	spi.Tx([]byte{0xff}, rx) // may cause unwanted heap allocations.
+
+This form sends 0xff and puts the result into rx buffer. Useful for reading from SD cards
+which require 0xff input on SI.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	// LSB not supported on rp2040.
+	LSBFirst	bool
+	// Mode's two most LSB are CPOL and CPHA. i.e. Mode==2 (0b10) is CPOL=1, CPHA=0
+	Mode	uint8
+	// Serial clock pin
+	SCK	Pin
+	// TX or Serial Data Out (MOSI if rp2040 is master)
+	SDO	Pin
+	// RX or Serial Data In (MISO if rp2040 is master)
+	SDI	Pin
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*rp.UART0_Type
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the RP2040.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the baudrate to be used for the UART.
+
+
+### func (*UART) SetFormat
+
+```go
+func (uart *UART) SetFormat(databits, stopbits uint8, parity UARTParity) error
+```
+
+SetFormat for number of data bits, stop bits, and parity for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) ClearStallEPIn
+
+```go
+func (dev *USBDevice) ClearStallEPIn(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB IN endpoint.
+
+
+### func (*USBDevice) ClearStallEPOut
+
+```go
+func (dev *USBDevice) ClearStallEPOut(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB OUT endpoint.
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+### func (*USBDevice) SetStallEPIn
+
+```go
+func (dev *USBDevice) SetStallEPIn(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB IN endpoint.
+
+
+### func (*USBDevice) SetStallEPOut
+
+```go
+func (dev *USBDevice) SetStallEPOut(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB OUT endpoint.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/circuitplay-bluefruit.md b/content/docs/reference/microcontrollers/machine/circuitplay-bluefruit.md
new file mode 100644
index 00000000..b5421fc5
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/circuitplay-bluefruit.md
@@ -0,0 +1,1557 @@
+
+---
+title: circuitplay-bluefruit
+---
+
+
+## Constants
+
+```go
+const HasLowFrequencyCrystal = false
+```
+
+
+
+```go
+const (
+	D0	= P0_30
+	D1	= P0_14
+	D2	= P0_05
+	D3	= P0_04
+	D4	= P1_02
+	D5	= P1_15
+	D6	= P0_02
+	D7	= P1_06
+	D8	= P0_13
+	D9	= P0_29
+	D10	= P0_03
+	D11	= P1_04
+	D12	= P0_26
+	D13	= P1_14
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A1	= P0_02
+	A2	= P0_29
+	A3	= P0_03
+	A4	= P0_04
+	A5	= P0_05
+	A6	= P0_30
+	A7	= P0_14
+	A8	= P0_28
+	A9	= P0_31
+)
+```
+
+Analog Pins
+
+
+```go
+const (
+	LED		= D13
+	NEOPIXELS	= D8
+	WS2812		= D8
+
+	BUTTONA	= D4
+	BUTTONB	= D5
+	SLIDER	= D7	// built-in slide switch
+
+	BUTTON	= BUTTONA
+	BUTTON1	= BUTTONB
+
+	LIGHTSENSOR	= A8
+	TEMPSENSOR	= A9
+)
+```
+
+
+
+```go
+const (
+	UART_TX_PIN	= P0_14	// PORTB
+	UART_RX_PIN	= P0_30	// PORTB
+)
+```
+
+UART0 pins (logical UART1)
+
+
+```go
+const (
+	SDA_PIN	= P0_05	// I2C0 external
+	SCL_PIN	= P0_04	// I2C0 external
+
+	SDA1_PIN	= P1_10	// I2C1 internal
+	SCL1_PIN	= P1_12	// I2C1 internal
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= P0_19	// SCK
+	SPI0_SDO_PIN	= P0_21	// SDO
+	SPI0_SDI_PIN	= P0_23	// SDI
+)
+```
+
+SPI pins (internal flash)
+
+
+```go
+const (
+	PDM_CLK_PIN	= P0_17	// CLK
+	PDM_DIN_PIN	= P0_16	// DIN
+)
+```
+
+PDM pins
+
+
+```go
+const (
+	P0_00	Pin	= 0
+	P0_01	Pin	= 1
+	P0_02	Pin	= 2
+	P0_03	Pin	= 3
+	P0_04	Pin	= 4
+	P0_05	Pin	= 5
+	P0_06	Pin	= 6
+	P0_07	Pin	= 7
+	P0_08	Pin	= 8
+	P0_09	Pin	= 9
+	P0_10	Pin	= 10
+	P0_11	Pin	= 11
+	P0_12	Pin	= 12
+	P0_13	Pin	= 13
+	P0_14	Pin	= 14
+	P0_15	Pin	= 15
+	P0_16	Pin	= 16
+	P0_17	Pin	= 17
+	P0_18	Pin	= 18
+	P0_19	Pin	= 19
+	P0_20	Pin	= 20
+	P0_21	Pin	= 21
+	P0_22	Pin	= 22
+	P0_23	Pin	= 23
+	P0_24	Pin	= 24
+	P0_25	Pin	= 25
+	P0_26	Pin	= 26
+	P0_27	Pin	= 27
+	P0_28	Pin	= 28
+	P0_29	Pin	= 29
+	P0_30	Pin	= 30
+	P0_31	Pin	= 31
+	P1_00	Pin	= 32
+	P1_01	Pin	= 33
+	P1_02	Pin	= 34
+	P1_03	Pin	= 35
+	P1_04	Pin	= 36
+	P1_05	Pin	= 37
+	P1_06	Pin	= 38
+	P1_07	Pin	= 39
+	P1_08	Pin	= 40
+	P1_09	Pin	= 41
+	P1_10	Pin	= 42
+	P1_11	Pin	= 43
+	P1_12	Pin	= 44
+	P1_13	Pin	= 45
+	P1_14	Pin	= 46
+	P1_15	Pin	= 47
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
+	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
+	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 36h)
+	WatchdogMaxTimeout = (0xffffffff * 1000) / 32768
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	DefaultUART = UART0
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	// UART0 is the hardware UART on the NRF SoC.
+	_UART0	= UART{Buffer: NewRingBuffer()}
+	UART0	= &_UART0
+)
+```
+
+UART
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	PWM0	= &PWM{PWM: nrf.PWM0}
+	PWM1	= &PWM{PWM: nrf.PWM1}
+	PWM2	= &PWM{PWM: nrf.PWM2}
+	PWM3	= &PWM{PWM: nrf.PWM3}
+)
+```
+
+PWM
+
+
+```go
+var (
+	I2C0	= &I2C{Bus: nrf.TWIM0, BusT: nrf.TWIS0}
+	I2C1	= &I2C{Bus: nrf.TWIM1, BusT: nrf.TWIS1}
+)
+```
+
+There are 2 I2C interfaces on the NRF.
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	SPI0	= &SPI{Bus: nrf.SPIM0, buf: new([1]byte)}
+	SPI1	= &SPI{Bus: nrf.SPIM1, buf: new([1]byte)}
+	SPI2	= &SPI{Bus: nrf.SPIM2, buf: new([1]byte)}
+)
+```
+
+There are 3 SPI interfaces on the NRF528xx.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader resets the chip into the UF2 bootloader. After reset, it
+can be flashed via nrfutil or by copying a UF2 file to the mass storage device
+
+
+### func EnterOTABootloader
+
+```go
+func EnterOTABootloader()
+```
+
+EnterOTABootloader resets the chip into the bootloader so that it can be
+flashed via an OTA update
+
+
+### func EnterSerialBootloader
+
+```go
+func EnterSerialBootloader()
+```
+
+EnterSerialBootloader resets the chip into the serial bootloader. After
+reset, it can be flashed using serial/nrfutil.
+
+
+### func EnterUF2Bootloader
+
+```go
+func EnterUF2Bootloader()
+```
+
+EnterUF2Bootloader resets the chip into the UF2 bootloader. After reset, it
+can be flashed via nrfutil or by copying a UF2 file to the mass storage device
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (ret uint32, err error)
+```
+
+GetRNG returns 32 bits of non-deterministic random data based on internal thermal noise.
+According to Nordic's documentation, the random output is suitable for cryptographic purposes.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() int32
+```
+
+ReadTemperature reads the silicon die temperature of the chip. The return
+value is in milli-celsius.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USBHID (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (*ADC) Configure
+
+```go
+func (a *ADC) Configure(config ADCConfig)
+```
+
+Configure configures an ADC pin to be able to read analog data.
+Reference voltage can be 150, 300, 600, 1200, 1800, 2400, 3000(default), 3600 mV
+Resolution can be 8, 10, 12(default), 14 bits
+SampleTime will be ceiled to 3(default), 5, 10, 15, 20 or 40(max) µS respectively
+Samples can be 1(default), 2, 4, 8, 16, 32, 64, 128, 256 samples
+
+
+### func (*ADC) Get
+
+```go
+func (a *ADC) Get() uint16
+```
+
+Get returns the current value of an ADC pin in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*nrf.TWIM_Type	// Called Bus to align with Bus field in nrf51
+	BusT	*nrf.TWIS_Type
+	mode	I2CMode
+}
+```
+
+I2C on the NRF528xx.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint8) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+Reply supplies the response data the controller.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) (err error)
+```
+
+Tx does a single I2C transaction at the specified address (when in controller mode).
+
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+WaitForEvent blocks the current go-routine until an I2C event is received (when in Target mode).
+
+The passed buffer will be populated for receive events, with the number of bytes
+received returned in count.  For other event types, buf is not modified and a count
+of zero is returned.
+
+For request events, the caller MUST call `Reply` to avoid hanging the i2c bus indefinitely.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDM
+
+```go
+type PDM struct {
+	device		*nrf.PDM_Type
+	defaultBuffer	int16
+}
+```
+
+PDM represents a PDM device
+
+
+
+### func (*PDM) Configure
+
+```go
+func (pdm *PDM) Configure(config PDMConfig) error
+```
+
+Configure is intended to set up the PDM interface prior to use.
+
+
+### func (*PDM) Read
+
+```go
+func (pdm *PDM) Read(buf []int16) (uint32, error)
+```
+
+Read stores a set of samples in the given target buffer.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWM
+
+```go
+type PWM struct {
+	PWM	*nrf.PWM_Type
+
+	channelValues	[4]volatile.Register16
+}
+```
+
+PWM is one PWM peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this PWM peripheral at
+once.
+
+
+
+### func (*PWM) Channel
+
+```go
+func (pwm *PWM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*PWM) Configure
+
+```go
+func (pwm *PWM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+On the nRF52 series, the maximum period is around 0.26s.
+
+
+### func (*PWM) Set
+
+```go
+func (pwm *PWM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	ch.Set(ch.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*PWM) SetInverting
+
+```go
+func (pwm *PWM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*PWM) SetPeriod
+
+```go
+func (pwm *PWM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*PWM) Top
+
+```go
+func (pwm *PWM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*nrf.SPIM_Type
+	buf	*[1]byte	// 1-byte buffer for the Transfer method
+}
+```
+
+SPI on the NRF.
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to set up the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous
+write/read interface, there must always be the same number of bytes written
+as bytes read. Therefore, if the number of bytes don't match it will be
+padded until they fit: if len(w) > len(r) the extra bytes received will be
+dropped and if len(w) < len(r) extra 0 bytes will be sent.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer *RingBuffer
+}
+```
+
+UART on the NRF.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/circuitplay-express.md b/content/docs/reference/microcontrollers/machine/circuitplay-express.md
new file mode 100644
index 00000000..0f125b6b
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/circuitplay-express.md
@@ -0,0 +1,1765 @@
+
+---
+title: circuitplay-express
+---
+
+
+## Constants
+
+```go
+const (
+	PA00	Pin	= 0	// peripherals: TCC2 channel 0, sercomI2CM1 SDA
+	PA01	Pin	= 1	// peripherals: TCC2 channel 1, sercomI2CM1 SCL
+	PA02	Pin	= 2
+	PA03	Pin	= 3
+	PA04	Pin	= 4	// peripherals: TCC0 channel 0
+	PA05	Pin	= 5	// peripherals: TCC0 channel 1
+	PA06	Pin	= 6	// peripherals: TCC1 channel 0
+	PA07	Pin	= 7	// peripherals: TCC1 channel 1
+	PA08	Pin	= 8	// peripherals: TCC0 channel 0, TCC1 channel 2, sercomI2CM0 SDA, sercomI2CM2 SDA
+	PA09	Pin	= 9	// peripherals: TCC0 channel 1, TCC1 channel 3, sercomI2CM0 SCL, sercomI2CM2 SCL
+	PA10	Pin	= 10	// peripherals: TCC1 channel 0, TCC0 channel 2
+	PA11	Pin	= 11	// peripherals: TCC1 channel 1, TCC0 channel 3
+	PA12	Pin	= 12	// peripherals: TCC2 channel 0, TCC0 channel 2, sercomI2CM2 SDA, sercomI2CM4 SDA
+	PA13	Pin	= 13	// peripherals: TCC2 channel 1, TCC0 channel 3, sercomI2CM2 SCL, sercomI2CM4 SCL
+	PA14	Pin	= 14	// peripherals: TCC0 channel 0
+	PA15	Pin	= 15	// peripherals: TCC0 channel 1
+	PA16	Pin	= 16	// peripherals: TCC2 channel 0, TCC0 channel 2, sercomI2CM1 SDA, sercomI2CM3 SDA
+	PA17	Pin	= 17	// peripherals: TCC2 channel 1, TCC0 channel 3, sercomI2CM1 SCL, sercomI2CM3 SCL
+	PA18	Pin	= 18	// peripherals: TCC0 channel 2
+	PA19	Pin	= 19	// peripherals: TCC0 channel 3
+	PA20	Pin	= 20	// peripherals: TCC0 channel 2
+	PA21	Pin	= 21	// peripherals: TCC0 channel 3
+	PA22	Pin	= 22	// peripherals: TCC0 channel 0, sercomI2CM3 SDA, sercomI2CM5 SDA
+	PA23	Pin	= 23	// peripherals: TCC0 channel 1, sercomI2CM3 SCL, sercomI2CM5 SCL
+	PA24	Pin	= 24	// peripherals: TCC1 channel 2
+	PA25	Pin	= 25	// peripherals: TCC1 channel 3
+	PA26	Pin	= 26
+	PA27	Pin	= 27
+	PA28	Pin	= 28
+	PA29	Pin	= 29
+	PA30	Pin	= 30	// peripherals: TCC1 channel 0
+	PA31	Pin	= 31	// peripherals: TCC1 channel 1
+	PB00	Pin	= 32
+	PB01	Pin	= 33
+	PB02	Pin	= 34	// peripherals: sercomI2CM5 SDA
+	PB03	Pin	= 35	// peripherals: sercomI2CM5 SCL
+	PB04	Pin	= 36
+	PB05	Pin	= 37
+	PB06	Pin	= 38
+	PB07	Pin	= 39
+	PB08	Pin	= 40	// peripherals: sercomI2CM4 SDA
+	PB09	Pin	= 41	// peripherals: sercomI2CM4 SCL
+	PB10	Pin	= 42	// peripherals: TCC0 channel 0
+	PB11	Pin	= 43	// peripherals: TCC0 channel 1
+	PB12	Pin	= 44	// peripherals: TCC0 channel 2, sercomI2CM4 SDA
+	PB13	Pin	= 45	// peripherals: TCC0 channel 3, sercomI2CM4 SCL
+	PB14	Pin	= 46
+	PB15	Pin	= 47
+	PB16	Pin	= 48	// peripherals: TCC0 channel 0, sercomI2CM5 SDA
+	PB17	Pin	= 49	// peripherals: TCC0 channel 1, sercomI2CM5 SCL
+	PB18	Pin	= 50
+	PB19	Pin	= 51
+	PB20	Pin	= 52
+	PB21	Pin	= 53
+	PB22	Pin	= 54
+	PB23	Pin	= 55
+	PB24	Pin	= 56
+	PB25	Pin	= 57
+	PB26	Pin	= 58
+	PB27	Pin	= 59
+	PB28	Pin	= 60
+	PB29	Pin	= 61
+	PB30	Pin	= 62	// peripherals: TCC0 channel 0, TCC1 channel 2, sercomI2CM5 SDA
+	PB31	Pin	= 63	// peripherals: TCC0 channel 1, TCC1 channel 3, sercomI2CM5 SCL
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	D0	= PB09
+	D1	= PB08
+	D2	= PB02
+	D3	= PB03
+	D4	= PA28
+	D5	= PA14
+	D6	= PA05
+	D7	= PA15
+	D8	= PB23
+	D9	= PA06
+	D10	= PA07
+	D11	= NoPin	// does not seem to exist
+	D12	= PA02
+	D13	= PA17	// PWM available
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A0	= PA02	// ADC/AIN[0]
+	A1	= PA05	// PWM available, also ADC/AIN[5]
+	A2	= PA06	// PWM available, also ADC/AIN[6]
+	A3	= PA07	// PWM available, also ADC/AIN[7]
+	A4	= PB03	// PORTB
+	A5	= PB02	// PORTB
+	A6	= PB09	// PORTB
+	A7	= PB08	// PORTB
+	A8	= PA11	// ADC/AIN[19]
+	A9	= PA09	// ADC/AIN[17]
+	A10	= PA04
+)
+```
+
+Analog Pins
+
+
+```go
+const (
+	LED		= D13
+	NEOPIXELS	= D8
+	WS2812		= D8
+
+	BUTTONA	= D4
+	BUTTONB	= D5
+	SLIDER	= D7	// built-in slide switch
+
+	BUTTON	= BUTTONA
+	BUTTON1	= BUTTONB
+
+	LIGHTSENSOR	= A8
+	TEMPSENSOR	= A9
+	PROXIMITY	= A10
+)
+```
+
+
+
+```go
+const (
+	USBCDC_DM_PIN	= PA24
+	USBCDC_DP_PIN	= PA25
+)
+```
+
+USBCDC pins (logical UART0)
+
+
+```go
+const (
+	UART_TX_PIN	= PB08	// PORTB
+	UART_RX_PIN	= PB09	// PORTB
+)
+```
+
+UART0 pins (logical UART1)
+
+
+```go
+const (
+	SDA_PIN	= PB02	// I2C0 external
+	SCL_PIN	= PB03	// I2C0 external
+
+	SDA1_PIN	= PA00	// I2C1 internal
+	SCL1_PIN	= PA01	// I2C1 internal
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= PA21	// SCK: SERCOM3/PAD[3]
+	SPI0_SDO_PIN	= PA20	// SDO: SERCOM3/PAD[2]
+	SPI0_SDI_PIN	= PA16	// SDI: SERCOM3/PAD[0]
+)
+```
+
+SPI pins (internal flash)
+
+
+```go
+const (
+	I2S_SCK_PIN	= PA10
+	I2S_SDO_PIN	= PA08
+	I2S_SDI_PIN	= NoPin
+	I2S_WS_PIN	= NoPin	// no WS, instead uses SCK to sync
+)
+```
+
+I2S pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const (
+	I2SModeSource	I2SMode	= iota
+	I2SModeReceiver
+	I2SModePDM
+	I2SModeSourceReceiver
+)
+```
+
+
+
+```go
+const (
+	I2StandardPhilips	I2SStandard	= iota
+	I2SStandardMSB
+	I2SStandardLSB
+)
+```
+
+
+
+```go
+const (
+	I2SClockSourceInternal	I2SClockSource	= iota
+	I2SClockSourceExternal
+)
+```
+
+
+
+```go
+const (
+	I2SDataFormatDefault	I2SDataFormat	= 0
+	I2SDataFormat8bit			= 8
+	I2SDataFormat16bit			= 16
+	I2SDataFormat24bit			= 24
+	I2SDataFormat32bit			= 32
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinAnalog	PinMode	= 1
+	PinSERCOM	PinMode	= 2
+	PinSERCOMAlt	PinMode	= 3
+	PinTimer	PinMode	= 4
+	PinTimerAlt	PinMode	= 5
+	PinCom		PinMode	= 6
+	//PinAC_CLK        PinMode = 7
+	PinDigital		PinMode	= 8
+	PinInput		PinMode	= 9
+	PinInputPullup		PinMode	= 10
+	PinOutput		PinMode	= 11
+	PinTCC			PinMode	= PinTimer
+	PinTCCAlt		PinMode	= PinTimerAlt
+	PinInputPulldown	PinMode	= 12
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
+	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
+	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (16s)
+	WatchdogMaxTimeout = (16384 * 1000) / 1024
+)
+```
+
+
+
+```go
+const (
+	// these are SAMD21 specific.
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Pos	= 0
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Mask	= 0x3FFF
+
+	usb_DEVICE_PCKSIZE_SIZE_Pos	= 28
+	usb_DEVICE_PCKSIZE_SIZE_Mask	= 0x7
+
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Pos	= 14
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Mask	= 0x3FFF
+
+	NumberOfUSBEndpoints	= 8
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	UART1	= &sercomUSART4
+
+	DefaultUART	= UART1
+)
+```
+
+UART1 on the Circuit Playground Express.
+
+
+```go
+var (
+	I2C0	= sercomI2CM5	// external device
+	I2C1	= sercomI2CM1	// internal device
+)
+```
+
+I2C on the Circuit Playground Express.
+
+
+```go
+var SPI0 = sercomSPIM3
+```
+
+SPI on the Circuit Playground Express.
+
+
+```go
+var (
+	ErrInvalidSampleFrequency = errors.New("i2s: invalid sample frequency")
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var I2S0 = I2S{Bus: sam.I2S}
+```
+
+
+
+```go
+var (
+	TCC0	= (*TCC)(sam.TCC0)
+	TCC1	= (*TCC)(sam.TCC1)
+	TCC2	= (*TCC)(sam.TCC2)
+)
+```
+
+The SAM D21 has three TCC peripherals, which have PWM as one feature.
+
+
+```go
+var (
+	DAC0 = DAC{}
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the SAMD21.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+Return the current CPU frequency in hertz.
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) and 16 bytes (128 bits) are common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig)
+```
+
+Configure configures a ADC pin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type DAC
+
+```go
+type DAC struct {
+}
+```
+
+DAC on the SAMD21.
+
+
+
+### func (DAC) Configure
+
+```go
+func (dac DAC) Configure(config DACConfig)
+```
+
+Configure the DAC.
+output pin must already be configured.
+
+
+### func (DAC) Set
+
+```go
+func (dac DAC) Set(value uint16) error
+```
+
+Set writes a single 16-bit value to the DAC.
+Since the ATSAMD21 only has a 10-bit DAC, the passed-in value will be scaled down.
+
+
+
+
+## type DACConfig
+
+```go
+type DACConfig struct {
+}
+```
+
+DACConfig placeholder for future expansion.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*sam.SERCOM_I2CM_Type
+	SERCOM	uint8
+}
+```
+
+I2C on the SAMD21.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteByte
+
+```go
+func (i2c *I2C) WriteByte(data byte) error
+```
+
+WriteByte writes a single byte to the I2C bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type I2S
+
+```go
+type I2S struct {
+	Bus		*sam.I2S_Type
+	Frequency	uint32
+	DataFormat	I2SDataFormat
+}
+```
+
+I2S
+
+
+
+### func (*I2S) Configure
+
+```go
+func (i2s *I2S) Configure(config I2SConfig) error
+```
+
+Configure is used to configure the I2S interface. You must call this
+before you can use the I2S bus.
+
+
+### func (*I2S) Enable
+
+```go
+func (i2s *I2S) Enable(enabled bool)
+```
+
+Enabled is used to enable or disable the I2S bus.
+
+
+### func (*I2S) ReadMono
+
+```go
+func (i2s *I2S) ReadMono(p []uint16) (n int, err error)
+```
+
+Read mono data from the I2S bus into the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) ReadStereo
+
+```go
+func (i2s *I2S) ReadStereo(p []uint32) (n int, err error)
+```
+
+Read stereo data from the I2S bus into the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) SetSampleFrequency
+
+```go
+func (i2s *I2S) SetSampleFrequency(freq uint32) error
+```
+
+SetSampleFrequency is used to set the sample frequency for the I2S bus.
+
+
+### func (*I2S) WriteMono
+
+```go
+func (i2s *I2S) WriteMono(p []uint16) (n int, err error)
+```
+
+Write mono data to the I2S bus from the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) WriteStereo
+
+```go
+func (i2s *I2S) WriteStereo(p []uint32) (n int, err error)
+```
+
+Write stereo data to the I2S bus from the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+
+
+## type I2SClockSource
+
+```go
+type I2SClockSource uint8
+```
+
+
+
+
+
+
+## type I2SConfig
+
+```go
+type I2SConfig struct {
+	// clock
+	SCK	Pin
+	// word select
+	WS	Pin
+	// data out
+	SDO	Pin
+	// data in
+	SDI		Pin
+	Mode		I2SMode
+	Standard	I2SStandard
+	ClockSource	I2SClockSource
+	DataFormat	I2SDataFormat
+	AudioFrequency	uint32
+	MainClockOutput	bool
+	Stereo		bool
+}
+```
+
+All fields are optional and may not be required or used on a particular platform.
+
+
+
+
+
+## type I2SDataFormat
+
+```go
+type I2SDataFormat uint8
+```
+
+
+
+
+
+
+## type I2SMode
+
+```go
+type I2SMode uint8
+```
+
+
+
+
+
+
+## type I2SStandard
+
+```go
+type I2SStandard uint8
+```
+
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when configured as an input or as
+an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*sam.SERCOM_SPI_Type
+	SERCOM	uint8
+}
+```
+
+SPI
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type TCC
+
+```go
+type TCC sam.TCC_Type
+```
+
+TCC is one timer/counter peripheral, which consists of a counter and multiple
+output channels (that can be connected to actual pins). You can set the
+frequency using SetPeriod, but only for all the channels in this TCC
+peripheral at once.
+
+
+
+### func (*TCC) Channel
+
+```go
+func (tcc *TCC) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin. Note that one channel may be
+shared between multiple pins, and so will have the same duty cycle. If this
+is not desirable, look for a different TCC peripheral or consider using a
+different pin.
+
+
+### func (*TCC) Configure
+
+```go
+func (tcc *TCC) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this TCC.
+
+
+### func (*TCC) Counter
+
+```go
+func (tcc *TCC) Counter() uint32
+```
+
+Counter returns the current counter value of the timer in this TCC
+peripheral. It may be useful for debugging.
+
+
+### func (*TCC) Set
+
+```go
+func (tcc *TCC) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle, in other words the fraction of time the channel output is high (or low
+when inverted). For example, to set it to a 25% duty cycle, use:
+
+	tcc.Set(channel, tcc.Top() / 4)
+
+tcc.Set(channel, 0) will set the output to low and tcc.Set(channel,
+tcc.Top()) will set the output to high, assuming the output isn't inverted.
+
+
+### func (*TCC) SetInverting
+
+```go
+func (tcc *TCC) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TCC) SetPeriod
+
+```go
+func (tcc *TCC) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this TCC peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the TCC peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TCC) Top
+
+```go
+func (tcc *TCC) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to Set
+(see Set documentation for more information).
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*sam.SERCOM_USART_Type
+	SERCOM		uint8
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the SAMD21.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/clue.md b/content/docs/reference/microcontrollers/machine/clue.md
new file mode 100644
index 00000000..0cdd9359
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/clue.md
@@ -0,0 +1,1583 @@
+
+---
+title: clue
+---
+
+
+## Constants
+
+```go
+const HasLowFrequencyCrystal = false
+```
+
+
+
+```go
+const (
+	D0	= P0_04
+	D1	= P0_05
+	D2	= P0_03
+	D3	= P0_28
+	D4	= P0_02
+	D5	= P1_02
+	D6	= P1_09
+	D7	= P0_07
+	D8	= P1_07
+	D9	= P0_27
+	D10	= P0_30
+	D11	= P1_10
+	D12	= P0_31
+	D13	= P0_08
+	D14	= P0_06
+	D15	= P0_26
+	D16	= P0_29
+	D17	= P1_01
+	D18	= P0_16
+	D19	= P0_25
+	D20	= P0_24
+	D29	= P0_14
+	D30	= P0_15
+	D31	= P0_12
+	D32	= P0_13
+	D33	= P1_03
+	D34	= P1_05
+	D35	= P0_00
+	D36	= P0_01
+	D37	= P0_19
+	D38	= P0_20
+	D39	= P0_17
+	D40	= P0_22
+	D41	= P0_23
+	D42	= P0_21
+	D43	= P0_10
+	D44	= P0_09
+	D45	= P1_06
+	D46	= P1_00
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A0	= D12
+	A1	= D16
+	A2	= D0
+	A3	= D1
+	A4	= D2
+	A5	= D3
+	A6	= D4
+	A7	= D10
+)
+```
+
+Analog Pins
+
+
+```go
+const (
+	LED		= D17
+	LED1		= LED
+	LED2		= D43
+	NEOPIXEL	= D18
+	WS2812		= D18
+
+	BUTTON_LEFT	= D5
+	BUTTON_RIGHT	= D11
+
+	// 240x240 ST7789 display is connected to these pins (use RowOffset = 80)
+	TFT_SCK		= D29
+	TFT_SDO		= D30
+	TFT_CS		= D31
+	TFT_DC		= D32
+	TFT_RESET	= D33
+	TFT_LITE	= D34
+
+	PDM_DAT	= D35
+	PDM_CLK	= D36
+
+	QSPI_SCK	= D37
+	QSPI_CS		= D38
+	QSPI_DATA0	= D39
+	QSPI_DATA1	= D40
+	QSPI_DATA2	= D41
+	QSPI_DATA3	= D42
+
+	SPEAKER	= D46
+)
+```
+
+
+
+```go
+const (
+	UART_RX_PIN	= D0
+	UART_TX_PIN	= D1
+)
+```
+
+UART0 pins (logical UART1)
+
+
+```go
+const (
+	SDA_PIN	= D20	// I2C0 external
+	SCL_PIN	= D19	// I2C0 external
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= D13	// SCK
+	SPI0_SDO_PIN	= D15	// SDO
+	SPI0_SDI_PIN	= D14	// SDI
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	P0_00	Pin	= 0
+	P0_01	Pin	= 1
+	P0_02	Pin	= 2
+	P0_03	Pin	= 3
+	P0_04	Pin	= 4
+	P0_05	Pin	= 5
+	P0_06	Pin	= 6
+	P0_07	Pin	= 7
+	P0_08	Pin	= 8
+	P0_09	Pin	= 9
+	P0_10	Pin	= 10
+	P0_11	Pin	= 11
+	P0_12	Pin	= 12
+	P0_13	Pin	= 13
+	P0_14	Pin	= 14
+	P0_15	Pin	= 15
+	P0_16	Pin	= 16
+	P0_17	Pin	= 17
+	P0_18	Pin	= 18
+	P0_19	Pin	= 19
+	P0_20	Pin	= 20
+	P0_21	Pin	= 21
+	P0_22	Pin	= 22
+	P0_23	Pin	= 23
+	P0_24	Pin	= 24
+	P0_25	Pin	= 25
+	P0_26	Pin	= 26
+	P0_27	Pin	= 27
+	P0_28	Pin	= 28
+	P0_29	Pin	= 29
+	P0_30	Pin	= 30
+	P0_31	Pin	= 31
+	P1_00	Pin	= 32
+	P1_01	Pin	= 33
+	P1_02	Pin	= 34
+	P1_03	Pin	= 35
+	P1_04	Pin	= 36
+	P1_05	Pin	= 37
+	P1_06	Pin	= 38
+	P1_07	Pin	= 39
+	P1_08	Pin	= 40
+	P1_09	Pin	= 41
+	P1_10	Pin	= 42
+	P1_11	Pin	= 43
+	P1_12	Pin	= 44
+	P1_13	Pin	= 45
+	P1_14	Pin	= 46
+	P1_15	Pin	= 47
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
+	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
+	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 36h)
+	WatchdogMaxTimeout = (0xffffffff * 1000) / 32768
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	DefaultUART = UART0
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	// UART0 is the hardware UART on the NRF SoC.
+	_UART0	= UART{Buffer: NewRingBuffer()}
+	UART0	= &_UART0
+)
+```
+
+UART
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	PWM0	= &PWM{PWM: nrf.PWM0}
+	PWM1	= &PWM{PWM: nrf.PWM1}
+	PWM2	= &PWM{PWM: nrf.PWM2}
+	PWM3	= &PWM{PWM: nrf.PWM3}
+)
+```
+
+PWM
+
+
+```go
+var (
+	I2C0	= &I2C{Bus: nrf.TWIM0, BusT: nrf.TWIS0}
+	I2C1	= &I2C{Bus: nrf.TWIM1, BusT: nrf.TWIS1}
+)
+```
+
+There are 2 I2C interfaces on the NRF.
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	SPI0	= &SPI{Bus: nrf.SPIM0, buf: new([1]byte)}
+	SPI1	= &SPI{Bus: nrf.SPIM1, buf: new([1]byte)}
+	SPI2	= &SPI{Bus: nrf.SPIM2, buf: new([1]byte)}
+)
+```
+
+There are 3 SPI interfaces on the NRF528xx.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader resets the chip into the UF2 bootloader. After reset, it
+can be flashed via nrfutil or by copying a UF2 file to the mass storage device
+
+
+### func EnterOTABootloader
+
+```go
+func EnterOTABootloader()
+```
+
+EnterOTABootloader resets the chip into the bootloader so that it can be
+flashed via an OTA update
+
+
+### func EnterSerialBootloader
+
+```go
+func EnterSerialBootloader()
+```
+
+EnterSerialBootloader resets the chip into the serial bootloader. After
+reset, it can be flashed using serial/nrfutil.
+
+
+### func EnterUF2Bootloader
+
+```go
+func EnterUF2Bootloader()
+```
+
+EnterUF2Bootloader resets the chip into the UF2 bootloader. After reset, it
+can be flashed via nrfutil or by copying a UF2 file to the mass storage device
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (ret uint32, err error)
+```
+
+GetRNG returns 32 bits of non-deterministic random data based on internal thermal noise.
+According to Nordic's documentation, the random output is suitable for cryptographic purposes.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() int32
+```
+
+ReadTemperature reads the silicon die temperature of the chip. The return
+value is in milli-celsius.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USBHID (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (*ADC) Configure
+
+```go
+func (a *ADC) Configure(config ADCConfig)
+```
+
+Configure configures an ADC pin to be able to read analog data.
+Reference voltage can be 150, 300, 600, 1200, 1800, 2400, 3000(default), 3600 mV
+Resolution can be 8, 10, 12(default), 14 bits
+SampleTime will be ceiled to 3(default), 5, 10, 15, 20 or 40(max) µS respectively
+Samples can be 1(default), 2, 4, 8, 16, 32, 64, 128, 256 samples
+
+
+### func (*ADC) Get
+
+```go
+func (a *ADC) Get() uint16
+```
+
+Get returns the current value of an ADC pin in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*nrf.TWIM_Type	// Called Bus to align with Bus field in nrf51
+	BusT	*nrf.TWIS_Type
+	mode	I2CMode
+}
+```
+
+I2C on the NRF528xx.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint8) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+Reply supplies the response data the controller.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) (err error)
+```
+
+Tx does a single I2C transaction at the specified address (when in controller mode).
+
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+WaitForEvent blocks the current go-routine until an I2C event is received (when in Target mode).
+
+The passed buffer will be populated for receive events, with the number of bytes
+received returned in count.  For other event types, buf is not modified and a count
+of zero is returned.
+
+For request events, the caller MUST call `Reply` to avoid hanging the i2c bus indefinitely.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDM
+
+```go
+type PDM struct {
+	device		*nrf.PDM_Type
+	defaultBuffer	int16
+}
+```
+
+PDM represents a PDM device
+
+
+
+### func (*PDM) Configure
+
+```go
+func (pdm *PDM) Configure(config PDMConfig) error
+```
+
+Configure is intended to set up the PDM interface prior to use.
+
+
+### func (*PDM) Read
+
+```go
+func (pdm *PDM) Read(buf []int16) (uint32, error)
+```
+
+Read stores a set of samples in the given target buffer.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWM
+
+```go
+type PWM struct {
+	PWM	*nrf.PWM_Type
+
+	channelValues	[4]volatile.Register16
+}
+```
+
+PWM is one PWM peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this PWM peripheral at
+once.
+
+
+
+### func (*PWM) Channel
+
+```go
+func (pwm *PWM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*PWM) Configure
+
+```go
+func (pwm *PWM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+On the nRF52 series, the maximum period is around 0.26s.
+
+
+### func (*PWM) Set
+
+```go
+func (pwm *PWM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	ch.Set(ch.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*PWM) SetInverting
+
+```go
+func (pwm *PWM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*PWM) SetPeriod
+
+```go
+func (pwm *PWM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*PWM) Top
+
+```go
+func (pwm *PWM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*nrf.SPIM_Type
+	buf	*[1]byte	// 1-byte buffer for the Transfer method
+}
+```
+
+SPI on the NRF.
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to set up the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous
+write/read interface, there must always be the same number of bytes written
+as bytes read. Therefore, if the number of bytes don't match it will be
+padded until they fit: if len(w) > len(r) the extra bytes received will be
+dropped and if len(w) < len(r) extra 0 bytes will be sent.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer *RingBuffer
+}
+```
+
+UART on the NRF.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/d1mini.md b/content/docs/reference/microcontrollers/machine/d1mini.md
new file mode 100644
index 00000000..ca461262
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/d1mini.md
@@ -0,0 +1,637 @@
+
+---
+title: d1mini
+---
+
+
+## Constants
+
+```go
+const (
+	D0	= GPIO16
+	D1	= GPIO5
+	D2	= GPIO4
+	D3	= GPIO0
+	D4	= GPIO2
+	D5	= GPIO14
+	D6	= GPIO12
+	D7	= GPIO13
+	D8	= GPIO15
+)
+```
+
+GPIO pins on the NodeMCU board.
+
+
+```go
+const LED = D4
+```
+
+Onboard blue LED (on the AI-Thinker module).
+
+
+```go
+const (
+	SPI0_SCK_PIN	= D5
+	SPI0_SDO_PIN	= D7
+	SPI0_SDI_PIN	= D6
+	SPI0_CS0_PIN	= D8
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	SDA_PIN	= D2
+	SCL_PIN	= D1
+)
+```
+
+I2C pins
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinOutput	PinMode	= iota
+	PinInput
+)
+```
+
+
+
+```go
+const (
+	GPIO0	Pin	= iota
+	GPIO1
+	GPIO2
+	GPIO3
+	GPIO4
+	GPIO5
+	GPIO6
+	GPIO7
+	GPIO8
+	GPIO9
+	GPIO10
+	GPIO11
+	GPIO12
+	GPIO13
+	GPIO14
+	GPIO15
+	GPIO16
+)
+```
+
+Hardware pin numbers
+
+
+```go
+const (
+	UART_TX_PIN	Pin	= 1
+	UART_RX_PIN	Pin	= 3
+)
+```
+
+Pins that are fixed by the chip.
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var UART0 = &_UART0
+```
+
+UART0 is a hardware UART that supports both TX and RX.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure sets the given pin as output or input pin.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+Warning: only use this on an output pin!
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+Warning: only use this on an output pin!
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set sets the output value of this pin to high (true) or low (false).
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer *RingBuffer
+}
+```
+
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART baud rate. TX and RX pins are fixed by the hardware so
+cannot be modified and will be ignored.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
diff --git a/content/microcontrollers/machine/digispark.md b/content/docs/reference/microcontrollers/machine/digispark.md
similarity index 59%
rename from content/microcontrollers/machine/digispark.md
rename to content/docs/reference/microcontrollers/machine/digispark.md
index eb2cbf37..25b9bba0 100644
--- a/content/microcontrollers/machine/digispark.md
+++ b/content/docs/reference/microcontrollers/machine/digispark.md
@@ -21,14 +21,26 @@ const (
 
 
 
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
 ```go
 const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
 )
 ```
 
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+Generic constants.
 
 
 ```go
@@ -69,6 +81,9 @@ const (
 
 ```go
 var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
 	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
 	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
 	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
@@ -80,20 +95,18 @@ var (
 
 
 ```go
-var I2C0 = I2C{}
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
 ```
 
-I2C0 is the only I2C interface on most AVRs.
 
 
 ```go
-var (
-	// UART0 is the hardware serial port on the AVR.
-	UART0 = UART{Buffer: NewRingBuffer()}
-)
+var Serial = NullSerial{}
 ```
 
-UART
+Serial is a null device: writes to it are ignored.
 
 
 
@@ -117,6 +130,14 @@ func InitADC()
 InitADC initializes the registers needed for ADC.
 
 
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
 ### func NewRingBuffer
 
 ```go
@@ -142,7 +163,7 @@ type ADC struct {
 ### func (ADC) Configure
 
 ```go
-func (a ADC) Configure()
+func (a ADC) Configure(ADCConfig)
 ```
 
 Configure configures a ADCPin to be able to be used to read data.
@@ -160,62 +181,92 @@ has an ADC of 10 bits precision so the lower 6 bits will be zero.
 
 
 
-## type I2C
+## type ADCConfig
 
 ```go
-type I2C struct {
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
 }
 ```
 
-I2C on AVR.
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
 
 
 
-### func (I2C) ReadRegister
+
+
+## type NullSerial
 
 ```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
+type NullSerial struct {
+}
 ```
 
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
 
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
 
 
-### func (I2C) Tx
+### func (NullSerial) Buffered
 
 ```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
+func (ns NullSerial) Buffered() int
 ```
 
-Tx is a dummy implementation. I2C has not been implemented for ATtiny
-devices.
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
 
 
-### func (I2C) WriteRegister
+### func (NullSerial) Configure
 
 ```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
+func (ns NullSerial) Configure(config UARTConfig) error
 ```
 
-WriteRegister transmits first the register and then the data to the
-peripheral device.
+Configure does nothing: the null serial has no configuration.
 
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
 
+### func (NullSerial) ReadByte
 
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
 
 
-## type PWM
+### func (NullSerial) Write
 
 ```go
-type PWM struct {
-	Pin Pin
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
 }
 ```
 
@@ -224,6 +275,29 @@ type PWM struct {
 
 
 
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
 ## type Pin
 
 ```go
@@ -251,7 +325,8 @@ Configure sets the pin to input or output.
 func (p Pin) Get() bool
 ```
 
-Get returns the current value of a GPIO pin.
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
 
 
 ### func (Pin) High
@@ -334,6 +409,9 @@ type PinConfig struct {
 type PinMode uint8
 ```
 
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
 
 
 
@@ -394,88 +472,6 @@ Used returns how many bytes in buffer have been used.
 
 
 
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the AVR is a dummy implementation. UART has not been implemented for ATtiny
-devices.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure is a dummy implementation. UART has not been implemented for ATtiny
-devices.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte is a dummy implementation. UART has not been implemented for ATtiny
-devices.
-
-
-
-
 ## type UARTConfig
 
 ```go
@@ -483,9 +479,14 @@ type UARTConfig struct {
 	BaudRate	uint32
 	TX		Pin
 	RX		Pin
+	RTS		Pin
+	CTS		Pin
 }
 ```
 
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
 
 
 
diff --git a/content/docs/reference/microcontrollers/machine/esp32-coreboard-v2.md b/content/docs/reference/microcontrollers/machine/esp32-coreboard-v2.md
new file mode 100644
index 00000000..ec3c8eb0
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/esp32-coreboard-v2.md
@@ -0,0 +1,1006 @@
+
+---
+title: esp32-coreboard-v2
+---
+
+
+## Constants
+
+```go
+const (
+	CLK	= GPIO6
+	CMD	= GPIO11
+	IO0	= GPIO0
+	IO1	= GPIO1
+	IO2	= GPIO2
+	IO3	= GPIO3
+	IO4	= GPIO4
+	IO5	= GPIO5
+	IO9	= GPIO9
+	IO10	= GPIO10
+	IO16	= GPIO16
+	IO17	= GPIO17
+	IO18	= GPIO18
+	IO19	= GPIO19
+	IO21	= GPIO21
+	IO22	= GPIO22
+	IO23	= GPIO23
+	IO25	= GPIO25
+	IO26	= GPIO26
+	IO27	= GPIO27
+	IO32	= GPIO32
+	IO33	= GPIO33
+	IO34	= GPIO34
+	IO35	= GPIO35
+	IO36	= GPIO36
+	IO39	= GPIO39
+	RXD	= GPIO3
+	SD0	= GPIO7
+	SD1	= GPIO8
+	SD2	= GPIO9
+	SD3	= GPIO10
+	SVN	= GPIO39
+	SVP	= GPIO36
+	TCK	= GPIO13
+	TD0	= GPIO15
+	TDI	= GPIO12
+	TMS	= GPIO14
+	TXD	= GPIO1
+)
+```
+
+
+
+```go
+const LED = IO2
+```
+
+Built-in LED on some ESP32 boards.
+
+
+```go
+const (
+	SPI0_SCK_PIN	= IO18
+	SPI0_SDO_PIN	= IO23
+	SPI0_SDI_PIN	= IO19
+	SPI0_CS0_PIN	= IO5
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	SDA_PIN	= IO21
+	SCL_PIN	= IO22
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	ADC0	Pin	= IO34
+	ADC1	Pin	= IO35
+	ADC2	Pin	= IO36
+	ADC3	Pin	= IO39
+)
+```
+
+ADC pins
+
+
+```go
+const (
+	UART_TX_PIN	= IO1
+	UART_RX_PIN	= IO3
+)
+```
+
+UART0 pins
+
+
+```go
+const (
+	UART1_TX_PIN	= IO9
+	UART1_RX_PIN	= IO10
+)
+```
+
+UART1 pins
+
+
+```go
+const (
+	PWM0_PIN	Pin	= IO2
+	PWM1_PIN	Pin	= IO0
+	PWM2_PIN	Pin	= IO4
+)
+```
+
+PWM pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinOutput	PinMode	= iota
+	PinInput
+	PinInputPullup
+	PinInputPulldown
+)
+```
+
+
+
+```go
+const (
+	GPIO0	Pin	= 0
+	GPIO1	Pin	= 1
+	GPIO2	Pin	= 2
+	GPIO3	Pin	= 3
+	GPIO4	Pin	= 4
+	GPIO5	Pin	= 5
+	GPIO6	Pin	= 6
+	GPIO7	Pin	= 7
+	GPIO8	Pin	= 8
+	GPIO9	Pin	= 9
+	GPIO10	Pin	= 10
+	GPIO11	Pin	= 11
+	GPIO12	Pin	= 12
+	GPIO13	Pin	= 13
+	GPIO14	Pin	= 14
+	GPIO15	Pin	= 15
+	GPIO16	Pin	= 16
+	GPIO17	Pin	= 17
+	GPIO18	Pin	= 18
+	GPIO19	Pin	= 19
+	GPIO21	Pin	= 21
+	GPIO22	Pin	= 22
+	GPIO23	Pin	= 23
+	GPIO25	Pin	= 25
+	GPIO26	Pin	= 26
+	GPIO27	Pin	= 27
+	GPIO32	Pin	= 32
+	GPIO33	Pin	= 33
+	GPIO34	Pin	= 34
+	GPIO35	Pin	= 35
+	GPIO36	Pin	= 36
+	GPIO37	Pin	= 37
+	GPIO38	Pin	= 38
+	GPIO39	Pin	= 39
+)
+```
+
+Hardware pin numbers
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	ErrInvalidSPIBus = errors.New("machine: invalid SPI bus")
+)
+```
+
+
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	UART0	= &_UART0
+	_UART0	= UART{Bus: esp.UART0, Buffer: NewRingBuffer()}
+	UART1	= &_UART1
+	_UART1	= UART{Bus: esp.UART1, Buffer: NewRingBuffer()}
+	UART2	= &_UART2
+	_UART2	= UART{Bus: esp.UART2, Buffer: NewRingBuffer()}
+)
+```
+
+
+
+```go
+var (
+	// SPI0 and SPI1 are reserved for use by the caching system etc.
+	SPI2	= &SPI{esp.SPI2}
+	SPI3	= &SPI{esp.SPI3}
+)
+```
+
+
+
+```go
+var (
+	I2C0	= &I2C{Bus: esp.I2C0, funcSCL: 29, funcSDA: 30}
+	I2C1	= &I2C{Bus: esp.I2C1, funcSCL: 95, funcSDA: 96}
+)
+```
+
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+CPUFrequency returns the current CPU frequency of the chip.
+Currently it is a fixed frequency but it may allow changing in the future.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus			*esp.I2C_Type
+	funcSCL, funcSDA	uint32
+	config			I2CConfig
+}
+```
+
+
+
+
+### func (*I2C) CheckDevice
+
+```go
+func (i2c *I2C) CheckDevice(addr uint16) bool
+```
+
+CheckDevice does an empty I2C transaction at the specified address.
+This can be used to find out if any device with that address is
+connected, e.g. for enumerating all devices on the bus.
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) (err error)
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32	// in Hz
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+Warning: only use this on an output pin!
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+Warning: only use this on an output pin!
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus *esp.SPI_Type
+}
+```
+
+Serial Peripheral Interface on the ESP32.
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure and make the SPI peripheral ready to use.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface. If you need to
+transfer larger amounts of data, Tx will be faster.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+This is accomplished by sending zero bits if r is bigger than w or discarding
+the incoming data if w is bigger than r.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig configures a SPI peripheral on the ESP32. Make sure to set at least
+SCK, SDO and SDI (possibly to NoPin if not in use). The default for LSBFirst
+(false) and Mode (0) are good for most applications. The frequency defaults
+to 1MHz if not set but can be configured up to 40MHz. Possible values are
+40MHz and integer divisions from 40MHz such as 20MHz, 13.3MHz, 10MHz, 8MHz,
+etc.
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Bus	*esp.UART_Type
+	Buffer	*RingBuffer
+}
+```
+
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/esp32-mini32.md b/content/docs/reference/microcontrollers/machine/esp32-mini32.md
new file mode 100644
index 00000000..c61ea0ff
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/esp32-mini32.md
@@ -0,0 +1,1006 @@
+
+---
+title: esp32-mini32
+---
+
+
+## Constants
+
+```go
+const (
+	CLK	= GPIO6
+	CMD	= GPIO11
+	IO0	= GPIO0
+	IO1	= GPIO1
+	IO2	= GPIO2
+	IO3	= GPIO3
+	IO4	= GPIO4
+	IO5	= GPIO5
+	IO9	= GPIO9
+	IO10	= GPIO10
+	IO16	= GPIO16
+	IO17	= GPIO17
+	IO18	= GPIO18
+	IO19	= GPIO19
+	IO21	= GPIO21
+	IO22	= GPIO22
+	IO23	= GPIO23
+	IO25	= GPIO25
+	IO26	= GPIO26
+	IO27	= GPIO27
+	IO32	= GPIO32
+	IO33	= GPIO33
+	IO34	= GPIO34
+	IO35	= GPIO35
+	IO36	= GPIO36
+	IO39	= GPIO39
+	RXD	= GPIO3
+	SD0	= GPIO7
+	SD1	= GPIO8
+	SD2	= GPIO9
+	SD3	= GPIO10
+	SVN	= GPIO39
+	SVP	= GPIO36
+	TCK	= GPIO13
+	TD0	= GPIO15
+	TDI	= GPIO12
+	TMS	= GPIO14
+	TXD	= GPIO1
+)
+```
+
+
+
+```go
+const LED = IO2
+```
+
+Built-in LED on some ESP32 boards.
+
+
+```go
+const (
+	SPI0_SCK_PIN	= IO18
+	SPI0_SDO_PIN	= IO23
+	SPI0_SDI_PIN	= IO19
+	SPI0_CS0_PIN	= IO5
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	SDA_PIN	= IO21
+	SCL_PIN	= IO22
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	ADC0	Pin	= IO34
+	ADC1	Pin	= IO35
+	ADC2	Pin	= IO36
+	ADC3	Pin	= IO39
+)
+```
+
+ADC pins
+
+
+```go
+const (
+	UART_TX_PIN	= IO1
+	UART_RX_PIN	= IO3
+)
+```
+
+UART0 pins
+
+
+```go
+const (
+	UART1_TX_PIN	= IO9
+	UART1_RX_PIN	= IO10
+)
+```
+
+UART1 pins
+
+
+```go
+const (
+	PWM0_PIN	Pin	= IO2
+	PWM1_PIN	Pin	= IO0
+	PWM2_PIN	Pin	= IO4
+)
+```
+
+PWM pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinOutput	PinMode	= iota
+	PinInput
+	PinInputPullup
+	PinInputPulldown
+)
+```
+
+
+
+```go
+const (
+	GPIO0	Pin	= 0
+	GPIO1	Pin	= 1
+	GPIO2	Pin	= 2
+	GPIO3	Pin	= 3
+	GPIO4	Pin	= 4
+	GPIO5	Pin	= 5
+	GPIO6	Pin	= 6
+	GPIO7	Pin	= 7
+	GPIO8	Pin	= 8
+	GPIO9	Pin	= 9
+	GPIO10	Pin	= 10
+	GPIO11	Pin	= 11
+	GPIO12	Pin	= 12
+	GPIO13	Pin	= 13
+	GPIO14	Pin	= 14
+	GPIO15	Pin	= 15
+	GPIO16	Pin	= 16
+	GPIO17	Pin	= 17
+	GPIO18	Pin	= 18
+	GPIO19	Pin	= 19
+	GPIO21	Pin	= 21
+	GPIO22	Pin	= 22
+	GPIO23	Pin	= 23
+	GPIO25	Pin	= 25
+	GPIO26	Pin	= 26
+	GPIO27	Pin	= 27
+	GPIO32	Pin	= 32
+	GPIO33	Pin	= 33
+	GPIO34	Pin	= 34
+	GPIO35	Pin	= 35
+	GPIO36	Pin	= 36
+	GPIO37	Pin	= 37
+	GPIO38	Pin	= 38
+	GPIO39	Pin	= 39
+)
+```
+
+Hardware pin numbers
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	ErrInvalidSPIBus = errors.New("machine: invalid SPI bus")
+)
+```
+
+
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	UART0	= &_UART0
+	_UART0	= UART{Bus: esp.UART0, Buffer: NewRingBuffer()}
+	UART1	= &_UART1
+	_UART1	= UART{Bus: esp.UART1, Buffer: NewRingBuffer()}
+	UART2	= &_UART2
+	_UART2	= UART{Bus: esp.UART2, Buffer: NewRingBuffer()}
+)
+```
+
+
+
+```go
+var (
+	// SPI0 and SPI1 are reserved for use by the caching system etc.
+	SPI2	= &SPI{esp.SPI2}
+	SPI3	= &SPI{esp.SPI3}
+)
+```
+
+
+
+```go
+var (
+	I2C0	= &I2C{Bus: esp.I2C0, funcSCL: 29, funcSDA: 30}
+	I2C1	= &I2C{Bus: esp.I2C1, funcSCL: 95, funcSDA: 96}
+)
+```
+
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+CPUFrequency returns the current CPU frequency of the chip.
+Currently it is a fixed frequency but it may allow changing in the future.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus			*esp.I2C_Type
+	funcSCL, funcSDA	uint32
+	config			I2CConfig
+}
+```
+
+
+
+
+### func (*I2C) CheckDevice
+
+```go
+func (i2c *I2C) CheckDevice(addr uint16) bool
+```
+
+CheckDevice does an empty I2C transaction at the specified address.
+This can be used to find out if any device with that address is
+connected, e.g. for enumerating all devices on the bus.
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) (err error)
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32	// in Hz
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+Warning: only use this on an output pin!
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+Warning: only use this on an output pin!
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus *esp.SPI_Type
+}
+```
+
+Serial Peripheral Interface on the ESP32.
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure and make the SPI peripheral ready to use.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface. If you need to
+transfer larger amounts of data, Tx will be faster.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+This is accomplished by sending zero bits if r is bigger than w or discarding
+the incoming data if w is bigger than r.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig configures a SPI peripheral on the ESP32. Make sure to set at least
+SCK, SDO and SDI (possibly to NoPin if not in use). The default for LSBFirst
+(false) and Mode (0) are good for most applications. The frequency defaults
+to 1MHz if not set but can be configured up to 40MHz. Possible values are
+40MHz and integer divisions from 40MHz such as 20MHz, 13.3MHz, 10MHz, 8MHz,
+etc.
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Bus	*esp.UART_Type
+	Buffer	*RingBuffer
+}
+```
+
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/feather-m0.md b/content/docs/reference/microcontrollers/machine/feather-m0.md
new file mode 100644
index 00000000..01633399
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/feather-m0.md
@@ -0,0 +1,1747 @@
+
+---
+title: feather-m0
+---
+
+
+## Constants
+
+```go
+const (
+	PA00	Pin	= 0	// peripherals: TCC2 channel 0, sercomI2CM1 SDA
+	PA01	Pin	= 1	// peripherals: TCC2 channel 1, sercomI2CM1 SCL
+	PA02	Pin	= 2
+	PA03	Pin	= 3
+	PA04	Pin	= 4	// peripherals: TCC0 channel 0
+	PA05	Pin	= 5	// peripherals: TCC0 channel 1
+	PA06	Pin	= 6	// peripherals: TCC1 channel 0
+	PA07	Pin	= 7	// peripherals: TCC1 channel 1
+	PA08	Pin	= 8	// peripherals: TCC0 channel 0, TCC1 channel 2, sercomI2CM0 SDA, sercomI2CM2 SDA
+	PA09	Pin	= 9	// peripherals: TCC0 channel 1, TCC1 channel 3, sercomI2CM0 SCL, sercomI2CM2 SCL
+	PA10	Pin	= 10	// peripherals: TCC1 channel 0, TCC0 channel 2
+	PA11	Pin	= 11	// peripherals: TCC1 channel 1, TCC0 channel 3
+	PA12	Pin	= 12	// peripherals: TCC2 channel 0, TCC0 channel 2, sercomI2CM2 SDA, sercomI2CM4 SDA
+	PA13	Pin	= 13	// peripherals: TCC2 channel 1, TCC0 channel 3, sercomI2CM2 SCL, sercomI2CM4 SCL
+	PA14	Pin	= 14	// peripherals: TCC0 channel 0
+	PA15	Pin	= 15	// peripherals: TCC0 channel 1
+	PA16	Pin	= 16	// peripherals: TCC2 channel 0, TCC0 channel 2, sercomI2CM1 SDA, sercomI2CM3 SDA
+	PA17	Pin	= 17	// peripherals: TCC2 channel 1, TCC0 channel 3, sercomI2CM1 SCL, sercomI2CM3 SCL
+	PA18	Pin	= 18	// peripherals: TCC0 channel 2
+	PA19	Pin	= 19	// peripherals: TCC0 channel 3
+	PA20	Pin	= 20	// peripherals: TCC0 channel 2
+	PA21	Pin	= 21	// peripherals: TCC0 channel 3
+	PA22	Pin	= 22	// peripherals: TCC0 channel 0, sercomI2CM3 SDA, sercomI2CM5 SDA
+	PA23	Pin	= 23	// peripherals: TCC0 channel 1, sercomI2CM3 SCL, sercomI2CM5 SCL
+	PA24	Pin	= 24	// peripherals: TCC1 channel 2
+	PA25	Pin	= 25	// peripherals: TCC1 channel 3
+	PA26	Pin	= 26
+	PA27	Pin	= 27
+	PA28	Pin	= 28
+	PA29	Pin	= 29
+	PA30	Pin	= 30	// peripherals: TCC1 channel 0
+	PA31	Pin	= 31	// peripherals: TCC1 channel 1
+	PB00	Pin	= 32
+	PB01	Pin	= 33
+	PB02	Pin	= 34	// peripherals: sercomI2CM5 SDA
+	PB03	Pin	= 35	// peripherals: sercomI2CM5 SCL
+	PB04	Pin	= 36
+	PB05	Pin	= 37
+	PB06	Pin	= 38
+	PB07	Pin	= 39
+	PB08	Pin	= 40	// peripherals: sercomI2CM4 SDA
+	PB09	Pin	= 41	// peripherals: sercomI2CM4 SCL
+	PB10	Pin	= 42	// peripherals: TCC0 channel 0
+	PB11	Pin	= 43	// peripherals: TCC0 channel 1
+	PB12	Pin	= 44	// peripherals: TCC0 channel 2, sercomI2CM4 SDA
+	PB13	Pin	= 45	// peripherals: TCC0 channel 3, sercomI2CM4 SCL
+	PB14	Pin	= 46
+	PB15	Pin	= 47
+	PB16	Pin	= 48	// peripherals: TCC0 channel 0, sercomI2CM5 SDA
+	PB17	Pin	= 49	// peripherals: TCC0 channel 1, sercomI2CM5 SCL
+	PB18	Pin	= 50
+	PB19	Pin	= 51
+	PB20	Pin	= 52
+	PB21	Pin	= 53
+	PB22	Pin	= 54
+	PB23	Pin	= 55
+	PB24	Pin	= 56
+	PB25	Pin	= 57
+	PB26	Pin	= 58
+	PB27	Pin	= 59
+	PB28	Pin	= 60
+	PB29	Pin	= 61
+	PB30	Pin	= 62	// peripherals: TCC0 channel 0, TCC1 channel 2, sercomI2CM5 SDA
+	PB31	Pin	= 63	// peripherals: TCC0 channel 1, TCC1 channel 3, sercomI2CM5 SCL
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	D0	= PA11	// UART0 RX
+	D1	= PA10	// UART0 TX
+	D2	= NoPin	// does not seem to exist
+	D3	= PA09
+	D4	= PA08
+	D5	= PA15	// PWM available
+	D6	= PA20	// PWM available
+	D7	= NoPin	// does not seem to exist
+	D8	= PA06
+	D9	= PA07	// PWM available
+	D10	= PA18	// can be used for PWM or UART1 TX
+	D11	= PA16	// can be used for PWM or UART1 RX
+	D12	= PA19	// PWM available
+	D13	= PA17	// PWM available
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A0	= PA02	// ADC/AIN[0]
+	A1	= PB08	// ADC/AIN[2]
+	A2	= PB09	// ADC/AIN[3]
+	A3	= PA04	// ADC/AIN[4]
+	A4	= PA05	// ADC/AIN[5]
+	A5	= PB02	// ADC/AIN[10]
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	LED = D13
+)
+```
+
+
+
+```go
+const (
+	USBCDC_DM_PIN	= PA24
+	USBCDC_DP_PIN	= PA25
+)
+```
+
+USBCDC pins
+
+
+```go
+const (
+	UART_TX_PIN	= D10
+	UART_RX_PIN	= D11
+)
+```
+
+UART1 pins
+
+
+```go
+const (
+	SDA_PIN	= PA22	// SDA: SERCOM3/PAD[0]
+	SCL_PIN	= PA23	// SCL: SERCOM3/PAD[1]
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= PB11	// SCK: SERCOM4/PAD[3]
+	SPI0_SDO_PIN	= PB10	// SDO: SERCOM4/PAD[2]
+	SPI0_SDI_PIN	= PA12	// SDI: SERCOM4/PAD[0]
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	I2S_SCK_PIN	= PA10
+	I2S_SDO_PIN	= PA08
+	I2S_SDI_PIN	= NoPin
+	I2S_WS_PIN	= NoPin	// TODO: figure out what this is on Feather M0.
+)
+```
+
+I2S pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const (
+	I2SModeSource	I2SMode	= iota
+	I2SModeReceiver
+	I2SModePDM
+	I2SModeSourceReceiver
+)
+```
+
+
+
+```go
+const (
+	I2StandardPhilips	I2SStandard	= iota
+	I2SStandardMSB
+	I2SStandardLSB
+)
+```
+
+
+
+```go
+const (
+	I2SClockSourceInternal	I2SClockSource	= iota
+	I2SClockSourceExternal
+)
+```
+
+
+
+```go
+const (
+	I2SDataFormatDefault	I2SDataFormat	= 0
+	I2SDataFormat8bit			= 8
+	I2SDataFormat16bit			= 16
+	I2SDataFormat24bit			= 24
+	I2SDataFormat32bit			= 32
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinAnalog	PinMode	= 1
+	PinSERCOM	PinMode	= 2
+	PinSERCOMAlt	PinMode	= 3
+	PinTimer	PinMode	= 4
+	PinTimerAlt	PinMode	= 5
+	PinCom		PinMode	= 6
+	//PinAC_CLK        PinMode = 7
+	PinDigital		PinMode	= 8
+	PinInput		PinMode	= 9
+	PinInputPullup		PinMode	= 10
+	PinOutput		PinMode	= 11
+	PinTCC			PinMode	= PinTimer
+	PinTCCAlt		PinMode	= PinTimerAlt
+	PinInputPulldown	PinMode	= 12
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
+	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
+	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (16s)
+	WatchdogMaxTimeout = (16384 * 1000) / 1024
+)
+```
+
+
+
+```go
+const (
+	// these are SAMD21 specific.
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Pos	= 0
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Mask	= 0x3FFF
+
+	usb_DEVICE_PCKSIZE_SIZE_Pos	= 28
+	usb_DEVICE_PCKSIZE_SIZE_Mask	= 0x7
+
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Pos	= 14
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Mask	= 0x3FFF
+
+	NumberOfUSBEndpoints	= 8
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var UART1 = &sercomUSART1
+```
+
+UART1 on the Feather M0.
+
+
+```go
+var (
+	I2C0 = sercomI2CM3
+)
+```
+
+I2C on the Feather M0.
+
+
+```go
+var SPI0 = sercomSPIM4
+```
+
+SPI on the Feather M0.
+
+
+```go
+var (
+	DefaultUART = UART1
+)
+```
+
+
+
+```go
+var (
+	ErrInvalidSampleFrequency = errors.New("i2s: invalid sample frequency")
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var I2S0 = I2S{Bus: sam.I2S}
+```
+
+
+
+```go
+var (
+	TCC0	= (*TCC)(sam.TCC0)
+	TCC1	= (*TCC)(sam.TCC1)
+	TCC2	= (*TCC)(sam.TCC2)
+)
+```
+
+The SAM D21 has three TCC peripherals, which have PWM as one feature.
+
+
+```go
+var (
+	DAC0 = DAC{}
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the SAMD21.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+Return the current CPU frequency in hertz.
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) and 16 bytes (128 bits) are common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig)
+```
+
+Configure configures a ADC pin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type DAC
+
+```go
+type DAC struct {
+}
+```
+
+DAC on the SAMD21.
+
+
+
+### func (DAC) Configure
+
+```go
+func (dac DAC) Configure(config DACConfig)
+```
+
+Configure the DAC.
+output pin must already be configured.
+
+
+### func (DAC) Set
+
+```go
+func (dac DAC) Set(value uint16) error
+```
+
+Set writes a single 16-bit value to the DAC.
+Since the ATSAMD21 only has a 10-bit DAC, the passed-in value will be scaled down.
+
+
+
+
+## type DACConfig
+
+```go
+type DACConfig struct {
+}
+```
+
+DACConfig placeholder for future expansion.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*sam.SERCOM_I2CM_Type
+	SERCOM	uint8
+}
+```
+
+I2C on the SAMD21.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteByte
+
+```go
+func (i2c *I2C) WriteByte(data byte) error
+```
+
+WriteByte writes a single byte to the I2C bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type I2S
+
+```go
+type I2S struct {
+	Bus		*sam.I2S_Type
+	Frequency	uint32
+	DataFormat	I2SDataFormat
+}
+```
+
+I2S
+
+
+
+### func (*I2S) Configure
+
+```go
+func (i2s *I2S) Configure(config I2SConfig) error
+```
+
+Configure is used to configure the I2S interface. You must call this
+before you can use the I2S bus.
+
+
+### func (*I2S) Enable
+
+```go
+func (i2s *I2S) Enable(enabled bool)
+```
+
+Enabled is used to enable or disable the I2S bus.
+
+
+### func (*I2S) ReadMono
+
+```go
+func (i2s *I2S) ReadMono(p []uint16) (n int, err error)
+```
+
+Read mono data from the I2S bus into the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) ReadStereo
+
+```go
+func (i2s *I2S) ReadStereo(p []uint32) (n int, err error)
+```
+
+Read stereo data from the I2S bus into the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) SetSampleFrequency
+
+```go
+func (i2s *I2S) SetSampleFrequency(freq uint32) error
+```
+
+SetSampleFrequency is used to set the sample frequency for the I2S bus.
+
+
+### func (*I2S) WriteMono
+
+```go
+func (i2s *I2S) WriteMono(p []uint16) (n int, err error)
+```
+
+Write mono data to the I2S bus from the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) WriteStereo
+
+```go
+func (i2s *I2S) WriteStereo(p []uint32) (n int, err error)
+```
+
+Write stereo data to the I2S bus from the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+
+
+## type I2SClockSource
+
+```go
+type I2SClockSource uint8
+```
+
+
+
+
+
+
+## type I2SConfig
+
+```go
+type I2SConfig struct {
+	// clock
+	SCK	Pin
+	// word select
+	WS	Pin
+	// data out
+	SDO	Pin
+	// data in
+	SDI		Pin
+	Mode		I2SMode
+	Standard	I2SStandard
+	ClockSource	I2SClockSource
+	DataFormat	I2SDataFormat
+	AudioFrequency	uint32
+	MainClockOutput	bool
+	Stereo		bool
+}
+```
+
+All fields are optional and may not be required or used on a particular platform.
+
+
+
+
+
+## type I2SDataFormat
+
+```go
+type I2SDataFormat uint8
+```
+
+
+
+
+
+
+## type I2SMode
+
+```go
+type I2SMode uint8
+```
+
+
+
+
+
+
+## type I2SStandard
+
+```go
+type I2SStandard uint8
+```
+
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when configured as an input or as
+an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*sam.SERCOM_SPI_Type
+	SERCOM	uint8
+}
+```
+
+SPI
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type TCC
+
+```go
+type TCC sam.TCC_Type
+```
+
+TCC is one timer/counter peripheral, which consists of a counter and multiple
+output channels (that can be connected to actual pins). You can set the
+frequency using SetPeriod, but only for all the channels in this TCC
+peripheral at once.
+
+
+
+### func (*TCC) Channel
+
+```go
+func (tcc *TCC) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin. Note that one channel may be
+shared between multiple pins, and so will have the same duty cycle. If this
+is not desirable, look for a different TCC peripheral or consider using a
+different pin.
+
+
+### func (*TCC) Configure
+
+```go
+func (tcc *TCC) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this TCC.
+
+
+### func (*TCC) Counter
+
+```go
+func (tcc *TCC) Counter() uint32
+```
+
+Counter returns the current counter value of the timer in this TCC
+peripheral. It may be useful for debugging.
+
+
+### func (*TCC) Set
+
+```go
+func (tcc *TCC) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle, in other words the fraction of time the channel output is high (or low
+when inverted). For example, to set it to a 25% duty cycle, use:
+
+	tcc.Set(channel, tcc.Top() / 4)
+
+tcc.Set(channel, 0) will set the output to low and tcc.Set(channel,
+tcc.Top()) will set the output to high, assuming the output isn't inverted.
+
+
+### func (*TCC) SetInverting
+
+```go
+func (tcc *TCC) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TCC) SetPeriod
+
+```go
+func (tcc *TCC) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this TCC peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the TCC peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TCC) Top
+
+```go
+func (tcc *TCC) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to Set
+(see Set documentation for more information).
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*sam.SERCOM_USART_Type
+	SERCOM		uint8
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the SAMD21.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/feather-m4-can.md b/content/docs/reference/microcontrollers/machine/feather-m4-can.md
new file mode 100644
index 00000000..12fb8b03
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/feather-m4-can.md
@@ -0,0 +1,1991 @@
+
+---
+title: feather-m4-can
+---
+
+
+## Constants
+
+```go
+const (
+	D0	= PB17	// UART0 RX/PWM available
+	D1	= PB16	// UART0 TX/PWM available
+	D4	= PA14	// PWM available
+	D5	= PA16	// PWM available
+	D6	= PA18	// PWM available
+	D7	= PB03	// neopixel power
+	D8	= PB02	// built-in neopixel
+	D9	= PA19	// PWM available
+	D10	= PA20	// can be used for PWM or UART1 TX
+	D11	= PA21	// can be used for PWM or UART1 RX
+	D12	= PA22	// PWM available
+	D13	= PA23	// PWM available
+	D21	= PA13	// PWM available
+	D22	= PA12	// PWM available
+	D23	= PB22	// PWM available
+	D24	= PB23	// PWM available
+	D25	= PA17	// PWM available
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A0	= PA02	// ADC/AIN[0]
+	A1	= PA05	// ADC/AIN[2]
+	A2	= PB08	// ADC/AIN[3]
+	A3	= PB09	// ADC/AIN[4]
+	A4	= PA04	// ADC/AIN[5]
+	A5	= PA06	// ADC/AIN[10]
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	LED		= D13
+	NEOPIXELS	= D8
+	WS2812		= D8
+)
+```
+
+
+
+```go
+const (
+	USBCDC_DM_PIN	= PA24
+	USBCDC_DP_PIN	= PA25
+)
+```
+
+USBCDC pins
+
+
+```go
+const (
+	UART_TX_PIN	= D1
+	UART_RX_PIN	= D0
+)
+```
+
+
+
+```go
+const (
+	UART2_TX_PIN	= A4
+	UART2_RX_PIN	= A5
+)
+```
+
+
+
+```go
+const (
+	SDA_PIN	= D22	// SDA: SERCOM2/PAD[0]
+	SCL_PIN	= D21	// SCL: SERCOM2/PAD[1]
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= D25	// SCK: SERCOM1/PAD[1]
+	SPI0_SDO_PIN	= D24	// SDO: SERCOM1/PAD[3]
+	SPI0_SDI_PIN	= D23	// SDI: SERCOM1/PAD[2]
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	CAN0_TX	= PA22
+	CAN0_RX	= PA23
+
+	CAN1_STANDBY	= PB12
+	CAN1_TX		= PB14
+	CAN1_RX		= PB15
+	BOOST_EN	= PB13	// power control of CAN1's TCAN1051HGV (H: enable)
+
+	CAN_STANDBY	= CAN1_STANDBY
+	CAN_S		= CAN1_STANDBY
+	CAN_TX		= CAN1_TX
+	CAN_RX		= CAN1_RX
+)
+```
+
+CAN pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinAnalog		PinMode	= 1
+	PinSERCOM		PinMode	= 2
+	PinSERCOMAlt		PinMode	= 3
+	PinTimer		PinMode	= 4
+	PinTimerAlt		PinMode	= 5
+	PinTCCPDEC		PinMode	= 6
+	PinCom			PinMode	= 7
+	PinSDHC			PinMode	= 8
+	PinI2S			PinMode	= 9
+	PinPCC			PinMode	= 10
+	PinGMAC			PinMode	= 11
+	PinACCLK		PinMode	= 12
+	PinCCL			PinMode	= 13
+	PinDigital		PinMode	= 14
+	PinInput		PinMode	= 15
+	PinInputPullup		PinMode	= 16
+	PinOutput		PinMode	= 17
+	PinTCCE			PinMode	= PinTimer
+	PinTCCF			PinMode	= PinTimerAlt
+	PinTCCG			PinMode	= PinTCCPDEC
+	PinInputPulldown	PinMode	= 18
+	PinCAN			PinMode	= 19
+	PinCAN0			PinMode	= PinSDHC
+	PinCAN1			PinMode	= PinCom
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
+	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
+	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	PA00	Pin	= 0
+	PA01	Pin	= 1
+	PA02	Pin	= 2
+	PA03	Pin	= 3
+	PA04	Pin	= 4
+	PA05	Pin	= 5
+	PA06	Pin	= 6
+	PA07	Pin	= 7
+	PA08	Pin	= 8	// peripherals: TCC0 channel 0, TCC1 channel 4, sercomI2CM0 SDA, sercomI2CM2 SDA
+	PA09	Pin	= 9	// peripherals: TCC0 channel 1, TCC1 channel 5, sercomI2CM0 SCL, sercomI2CM2 SCL
+	PA10	Pin	= 10	// peripherals: TCC0 channel 2, TCC1 channel 6
+	PA11	Pin	= 11	// peripherals: TCC0 channel 3, TCC1 channel 7
+	PA12	Pin	= 12	// peripherals: TCC0 channel 6, TCC1 channel 2, sercomI2CM2 SDA, sercomI2CM4 SDA
+	PA13	Pin	= 13	// peripherals: TCC0 channel 7, TCC1 channel 3, sercomI2CM2 SCL, sercomI2CM4 SCL
+	PA14	Pin	= 14	// peripherals: TCC2 channel 0, TCC1 channel 2
+	PA15	Pin	= 15	// peripherals: TCC2 channel 1, TCC1 channel 3
+	PA16	Pin	= 16	// peripherals: TCC1 channel 0, TCC0 channel 4, sercomI2CM1 SDA, sercomI2CM3 SDA
+	PA17	Pin	= 17	// peripherals: TCC1 channel 1, TCC0 channel 5, sercomI2CM1 SCL, sercomI2CM3 SCL
+	PA18	Pin	= 18	// peripherals: TCC1 channel 2, TCC0 channel 6
+	PA19	Pin	= 19	// peripherals: TCC1 channel 3, TCC0 channel 7
+	PA20	Pin	= 20	// peripherals: TCC1 channel 4, TCC0 channel 0
+	PA21	Pin	= 21	// peripherals: TCC1 channel 5, TCC0 channel 1
+	PA22	Pin	= 22	// peripherals: TCC1 channel 6, TCC0 channel 2, sercomI2CM3 SDA, sercomI2CM5 SDA
+	PA23	Pin	= 23	// peripherals: TCC1 channel 7, TCC0 channel 3, sercomI2CM3 SCL, sercomI2CM5 SCL
+	PA24	Pin	= 24	// peripherals: TCC2 channel 2
+	PA25	Pin	= 25	// peripherals: TCC2 channel 3
+	PA26	Pin	= 26
+	PA27	Pin	= 27
+	PA28	Pin	= 28
+	PA29	Pin	= 29
+	PA30	Pin	= 30	// peripherals: TCC2 channel 0
+	PA31	Pin	= 31	// peripherals: TCC2 channel 1
+	PB00	Pin	= 32
+	PB01	Pin	= 33
+	PB02	Pin	= 34	// peripherals: TCC2 channel 2
+	PB03	Pin	= 35	// peripherals: TCC2 channel 3
+	PB04	Pin	= 36
+	PB05	Pin	= 37
+	PB06	Pin	= 38
+	PB07	Pin	= 39
+	PB08	Pin	= 40
+	PB09	Pin	= 41
+	PB10	Pin	= 42	// peripherals: TCC0 channel 4, TCC1 channel 0
+	PB11	Pin	= 43	// peripherals: TCC0 channel 5, TCC1 channel 1
+	PB12	Pin	= 44	// peripherals: TCC3 channel 0, TCC0 channel 0
+	PB13	Pin	= 45	// peripherals: TCC3 channel 1, TCC0 channel 1
+	PB14	Pin	= 46	// peripherals: TCC4 channel 0, TCC0 channel 2
+	PB15	Pin	= 47	// peripherals: TCC4 channel 1, TCC0 channel 3
+	PB16	Pin	= 48	// peripherals: TCC3 channel 0, TCC0 channel 4
+	PB17	Pin	= 49	// peripherals: TCC3 channel 1, TCC0 channel 5
+	PB18	Pin	= 50	// peripherals: TCC1 channel 0
+	PB19	Pin	= 51	// peripherals: TCC1 channel 1
+	PB20	Pin	= 52	// peripherals: TCC1 channel 2
+	PB21	Pin	= 53	// peripherals: TCC1 channel 3
+	PB22	Pin	= 54
+	PB23	Pin	= 55
+	PB24	Pin	= 56
+	PB25	Pin	= 57
+	PB26	Pin	= 58	// peripherals: TCC1 channel 2
+	PB27	Pin	= 59	// peripherals: TCC1 channel 3
+	PB28	Pin	= 60	// peripherals: TCC1 channel 4
+	PB29	Pin	= 61	// peripherals: TCC1 channel 5
+	PB30	Pin	= 62	// peripherals: TCC4 channel 0, TCC0 channel 6
+	PB31	Pin	= 63	// peripherals: TCC4 channel 1, TCC0 channel 7
+	PC00	Pin	= 64
+	PC01	Pin	= 65
+	PC02	Pin	= 66
+	PC03	Pin	= 67
+	PC04	Pin	= 68	// peripherals: TCC0 channel 0
+	PC05	Pin	= 69	// peripherals: TCC0 channel 1
+	PC06	Pin	= 70
+	PC07	Pin	= 71
+	PC08	Pin	= 72
+	PC09	Pin	= 73
+	PC10	Pin	= 74	// peripherals: TCC0 channel 0, TCC1 channel 4
+	PC11	Pin	= 75	// peripherals: TCC0 channel 1, TCC1 channel 5
+	PC12	Pin	= 76	// peripherals: TCC0 channel 2, TCC1 channel 6
+	PC13	Pin	= 77	// peripherals: TCC0 channel 3, TCC1 channel 7
+	PC14	Pin	= 78	// peripherals: TCC0 channel 4, TCC1 channel 0
+	PC15	Pin	= 79	// peripherals: TCC0 channel 5, TCC1 channel 1
+	PC16	Pin	= 80	// peripherals: TCC0 channel 0
+	PC17	Pin	= 81	// peripherals: TCC0 channel 1
+	PC18	Pin	= 82	// peripherals: TCC0 channel 2
+	PC19	Pin	= 83	// peripherals: TCC0 channel 3
+	PC20	Pin	= 84	// peripherals: TCC0 channel 4
+	PC21	Pin	= 85	// peripherals: TCC0 channel 5
+	PC22	Pin	= 86	// peripherals: TCC0 channel 6
+	PC23	Pin	= 87	// peripherals: TCC0 channel 7
+	PC24	Pin	= 88
+	PC25	Pin	= 89
+	PC26	Pin	= 90
+	PC27	Pin	= 91
+	PC28	Pin	= 92
+	PC29	Pin	= 93
+	PC30	Pin	= 94
+	PC31	Pin	= 95
+	PD00	Pin	= 96
+	PD01	Pin	= 97
+	PD02	Pin	= 98
+	PD03	Pin	= 99
+	PD04	Pin	= 100
+	PD05	Pin	= 101
+	PD06	Pin	= 102
+	PD07	Pin	= 103
+	PD08	Pin	= 104	// peripherals: TCC0 channel 1, sercomI2CM6 SDA, sercomI2CM7 SDA
+	PD09	Pin	= 105	// peripherals: TCC0 channel 2, sercomI2CM6 SCL, sercomI2CM7 SCL
+	PD10	Pin	= 106	// peripherals: TCC0 channel 3
+	PD11	Pin	= 107	// peripherals: TCC0 channel 4
+	PD12	Pin	= 108	// peripherals: TCC0 channel 5
+	PD13	Pin	= 109	// peripherals: TCC0 channel 6
+	PD14	Pin	= 110
+	PD15	Pin	= 111
+	PD16	Pin	= 112
+	PD17	Pin	= 113
+	PD18	Pin	= 114
+	PD19	Pin	= 115
+	PD20	Pin	= 116	// peripherals: TCC1 channel 0
+	PD21	Pin	= 117	// peripherals: TCC1 channel 1
+	PD22	Pin	= 118
+	PD23	Pin	= 119
+	PD24	Pin	= 120
+	PD25	Pin	= 121
+	PD26	Pin	= 122
+	PD27	Pin	= 123
+	PD28	Pin	= 124
+	PD29	Pin	= 125
+	PD30	Pin	= 126
+	PD31	Pin	= 127
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	// SERCOM_FREQ_REF is always reference frequency on SAMD51 regardless of CPU speed.
+	SERCOM_FREQ_REF		= 48000000
+	SERCOM_FREQ_REF_GCLK0	= 120000000
+
+	// Default rise time in nanoseconds, based on 4.7K ohm pull up resistors
+	riseTimeNanoseconds	= 125
+
+	// wire bus states
+	wireUnknownState	= 0
+	wireIdleState		= 1
+	wireOwnerState		= 2
+	wireBusyState		= 3
+
+	// wire commands
+	wireCmdNoAction		= 0
+	wireCmdRepeatStart	= 1
+	wireCmdRead		= 2
+	wireCmdStop		= 3
+)
+```
+
+
+
+```go
+const (
+	QSPI_SCK	= PB10
+	QSPI_CS		= PB11
+	QSPI_DATA0	= PA08
+	QSPI_DATA1	= PA09
+	QSPI_DATA2	= PA10
+	QSPI_DATA3	= PA11
+)
+```
+
+The QSPI peripheral on ATSAMD51 is only available on the following pins
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (16s)
+	WatchdogMaxTimeout = (16384 * 1000) / 1024	// CYC16384/1024kHz
+)
+```
+
+
+
+```go
+const (
+	// these are SAMD51 specific.
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Pos	= 0
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Mask	= 0x3FFF
+
+	usb_DEVICE_PCKSIZE_SIZE_Pos	= 28
+	usb_DEVICE_PCKSIZE_SIZE_Mask	= 0x7
+
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Pos	= 14
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Mask	= 0x3FFF
+
+	NumberOfUSBEndpoints	= 8
+)
+```
+
+
+
+```go
+const HSRAM_SIZE = 0x00030000
+```
+
+
+
+```go
+const (
+	CANRxFifoSize	= 16
+	CANTxFifoSize	= 16
+	CANEvFifoSize	= 16
+)
+```
+
+
+
+```go
+const (
+	CANTransferRate125kbps	CANTransferRate	= 125000
+	CANTransferRate250kbps	CANTransferRate	= 250000
+	CANTransferRate500kbps	CANTransferRate	= 500000
+	CANTransferRate1000kbps	CANTransferRate	= 1000000
+	CANTransferRate2000kbps	CANTransferRate	= 2000000
+	CANTransferRate4000kbps	CANTransferRate	= 4000000
+)
+```
+
+CAN transfer rates for CANConfig
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	UART1	= &sercomUSART5
+
+	UART2	= &sercomUSART0
+)
+```
+
+
+
+```go
+var (
+	I2C0 = sercomI2CM2
+)
+```
+
+I2C on the Feather M4 CAN.
+
+
+```go
+var SPI0 = sercomSPIM1
+```
+
+SPI on the Feather M4 CAN.
+
+
+```go
+var (
+	CAN0	= CAN{
+		Bus: sam.CAN0,
+	}
+
+	CAN1	= CAN{
+		Bus: sam.CAN1,
+	}
+)
+```
+
+CAN on the Feather M4 CAN.
+
+
+```go
+var (
+	DefaultUART = UART1
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	DAC0	= DAC{Channel: 0}
+	DAC1	= DAC{Channel: 1}
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the SAMD51.
+
+
+```go
+var (
+	TCC0	= (*TCC)(sam.TCC0)
+	TCC1	= (*TCC)(sam.TCC1)
+	TCC2	= (*TCC)(sam.TCC2)
+	TCC3	= (*TCC)(sam.TCC3)
+	TCC4	= (*TCC)(sam.TCC4)
+)
+```
+
+This chip has five TCC peripherals, which have PWM as one feature.
+
+
+```go
+var CANRxFifo [2][(8 + 64) * CANRxFifoSize]byte
+```
+
+
+
+```go
+var CANTxFifo [2][(8 + 64) * CANTxFifoSize]byte
+```
+
+
+
+```go
+var CANEvFifo [2][(8) * CANEvFifoSize]byte
+```
+
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CANDlcToLength
+
+```go
+func CANDlcToLength(dlc byte, isFD bool) byte
+```
+
+CANDlcToLength() converts a DLC value to its actual length.
+
+
+### func CANLengthToDlc
+
+```go
+func CANLengthToDlc(length byte, isFD bool) byte
+```
+
+CANLengthToDlc() converts its actual length to a DLC value.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) and 16 bytes (128 bits) are common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of cryptographically secure random data
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig)
+```
+
+Configure configures a ADCPin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type CAN
+
+```go
+type CAN struct {
+	Bus *sam.CAN_Type
+}
+```
+
+
+
+
+### func (*CAN) Configure
+
+```go
+func (can *CAN) Configure(config CANConfig) error
+```
+
+Configure this CAN peripheral with the given configuration.
+
+
+### func (*CAN) Rx
+
+```go
+func (can *CAN) Rx() (id uint32, dlc byte, data []byte, isFd, isExtendedID bool)
+```
+
+Rx receives a CAN frame. It is easier to use than RxRaw, but not as
+flexible.
+
+
+### func (*CAN) RxFifoIsEmpty
+
+```go
+func (can *CAN) RxFifoIsEmpty() bool
+```
+
+RxFifoIsEmpty returns whether RxFifo is empty or not.
+
+
+### func (*CAN) RxFifoIsFull
+
+```go
+func (can *CAN) RxFifoIsFull() bool
+```
+
+RxFifoIsFull returns whether RxFifo is full or not.
+
+
+### func (*CAN) RxFifoSize
+
+```go
+func (can *CAN) RxFifoSize() int
+```
+
+RxFifoSize returns the number of CAN Frames currently stored in the RXFifo.
+
+
+### func (*CAN) RxRaw
+
+```go
+func (can *CAN) RxRaw(e *CANRxBufferElement)
+```
+
+RxRaw copies the received CAN frame to CANRxBufferElement.
+
+
+### func (*CAN) SetInterrupt
+
+```go
+func (can *CAN) SetInterrupt(ie uint32, callback func(*CAN)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular CAN state.
+
+This call will replace a previously set callback. You can pass a nil func
+to unset the CAN interrupt. If you do so, the change parameter is ignored
+and can be set to any value (such as 0).
+
+
+### func (*CAN) Tx
+
+```go
+func (can *CAN) Tx(id uint32, data []byte, isFD, isExtendedID bool)
+```
+
+The Tx transmits CAN frames. It is easier to use than TxRaw, but not as
+flexible.
+
+
+### func (*CAN) TxFifoFreeLevel
+
+```go
+func (can *CAN) TxFifoFreeLevel() int
+```
+
+TxFifoFreeLevel returns how many messages can still be set in the TxFifo.
+
+
+### func (*CAN) TxFifoIsFull
+
+```go
+func (can *CAN) TxFifoIsFull() bool
+```
+
+TxFifoIsFull returns whether TxFifo is full or not.
+
+
+### func (*CAN) TxRaw
+
+```go
+func (can *CAN) TxRaw(e *CANTxBufferElement)
+```
+
+TxRaw sends a CAN Frame according to CANTxBufferElement.
+
+
+
+
+## type CANConfig
+
+```go
+type CANConfig struct {
+	TransferRate	CANTransferRate
+	TransferRateFD	CANTransferRate
+	Tx		Pin
+	Rx		Pin
+	Standby		Pin
+}
+```
+
+CANConfig holds CAN configuration parameters. Tx and Rx need to be
+specified with some pins. When the Standby Pin is specified, configure it
+as an output pin and output Low in Configure(). If this operation is not
+necessary, specify NoPin.
+
+
+
+
+
+## type CANRxBufferElement
+
+```go
+type CANRxBufferElement struct {
+	ESI	bool
+	XTD	bool
+	RTR	bool
+	ID	uint32
+	ANMF	bool
+	FIDX	uint8
+	FDF	bool
+	BRS	bool
+	DLC	uint8
+	RXTS	uint16
+	DB	[64]uint8
+}
+```
+
+CANRxBufferElement is a struct that corresponds to the same5x Rx Buffer and
+FIFO Element.
+
+
+
+### func (CANRxBufferElement) Data
+
+```go
+func (e CANRxBufferElement) Data() []byte
+```
+
+Data returns the received data as a slice of the size according to dlc.
+
+
+### func (CANRxBufferElement) Length
+
+```go
+func (e CANRxBufferElement) Length() byte
+```
+
+Length returns its actual length.
+
+
+
+
+## type CANTransferRate
+
+```go
+type CANTransferRate uint32
+```
+
+
+
+
+
+
+## type CANTxBufferElement
+
+```go
+type CANTxBufferElement struct {
+	ESI	bool
+	XTD	bool
+	RTR	bool
+	ID	uint32
+	MM	uint8
+	EFC	bool
+	FDF	bool
+	BRS	bool
+	DLC	uint8
+	DB	[64]uint8
+}
+```
+
+CANTxBufferElement is a struct that corresponds to the same5x' Tx Buffer
+Element.
+
+
+
+
+
+## type DAC
+
+```go
+type DAC struct {
+	Channel uint8
+}
+```
+
+DAC on the SAMD51.
+
+
+
+### func (DAC) Configure
+
+```go
+func (dac DAC) Configure(config DACConfig)
+```
+
+Configure the DAC.
+output pin must already be configured.
+
+
+### func (DAC) Set
+
+```go
+func (dac DAC) Set(value uint16) error
+```
+
+Set writes a single 16-bit value to the DAC.
+Since the ATSAMD51 only has a 12-bit DAC, the passed-in value will be scaled down.
+
+
+
+
+## type DACConfig
+
+```go
+type DACConfig struct {
+}
+```
+
+DACConfig placeholder for future expansion.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*sam.SERCOM_I2CM_Type
+	SERCOM	uint8
+}
+```
+
+I2C on the SAMD51.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteByte
+
+```go
+func (i2c *I2C) WriteByte(data byte) error
+```
+
+WriteByte writes a single byte to the I2C bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when configured as an input or as
+an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+### func (Pin) Toggle
+
+```go
+func (p Pin) Toggle()
+```
+
+Toggle switches an output pin from low to high or from high to low.
+Warning: only use this on an output pin!
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*sam.SERCOM_SPIM_Type
+	SERCOM	uint8
+}
+```
+
+SPI
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type TCC
+
+```go
+type TCC sam.TCC_Type
+```
+
+TCC is one timer peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this timer peripheral at
+once.
+
+
+
+### func (*TCC) Channel
+
+```go
+func (tcc *TCC) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin. Note that one channel may be
+shared between multiple pins, and so will have the same duty cycle. If this
+is not desirable, look for a different TCC or consider using a different pin.
+
+
+### func (*TCC) Configure
+
+```go
+func (tcc *TCC) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this TCC.
+
+
+### func (*TCC) Counter
+
+```go
+func (tcc *TCC) Counter() uint32
+```
+
+Counter returns the current counter value of the timer in this TCC
+peripheral. It may be useful for debugging.
+
+
+### func (*TCC) Set
+
+```go
+func (tcc *TCC) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle, in other words the fraction of time the channel output is high (or low
+when inverted). For example, to set it to a 25% duty cycle, use:
+
+	tcc.Set(channel, tcc.Top() / 4)
+
+tcc.Set(channel, 0) will set the output to low and tcc.Set(channel,
+tcc.Top()) will set the output to high, assuming the output isn't inverted.
+
+
+### func (*TCC) SetInverting
+
+```go
+func (tcc *TCC) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TCC) SetPeriod
+
+```go
+func (tcc *TCC) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this TCC peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the TCC peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TCC) Top
+
+```go
+func (tcc *TCC) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+tcc.Set (see tcc.Set for more information).
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*sam.SERCOM_USART_INT_Type
+	SERCOM		uint8
+	Interrupt	interrupt.Interrupt	// RXC interrupt
+}
+```
+
+UART on the SAMD51.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/feather-m4.md b/content/docs/reference/microcontrollers/machine/feather-m4.md
new file mode 100644
index 00000000..104f251f
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/feather-m4.md
@@ -0,0 +1,1670 @@
+
+---
+title: feather-m4
+---
+
+
+## Constants
+
+```go
+const (
+	D0	= PB17	// UART0 RX/PWM available
+	D1	= PB16	// UART0 TX/PWM available
+	D4	= PA14	// PWM available
+	D5	= PA16	// PWM available
+	D6	= PA18	// PWM available
+	D8	= PB03	// built-in neopixel
+	D9	= PA19	// PWM available
+	D10	= PA20	// can be used for PWM or UART1 TX
+	D11	= PA21	// can be used for PWM or UART1 RX
+	D12	= PA22	// PWM available
+	D13	= PA23	// PWM available
+	D21	= PA13	// PWM available
+	D22	= PA12	// PWM available
+	D23	= PB22	// PWM available
+	D24	= PB23	// PWM available
+	D25	= PA17	// PWM available
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A0	= PA02	// ADC/AIN[0]
+	A1	= PA05	// ADC/AIN[2]
+	A2	= PB08	// ADC/AIN[3]
+	A3	= PB09	// ADC/AIN[4]
+	A4	= PA04	// ADC/AIN[5]
+	A5	= PA06	// ADC/AIN[10]
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	LED	= D13
+	WS2812	= D8
+)
+```
+
+
+
+```go
+const (
+	USBCDC_DM_PIN	= PA24
+	USBCDC_DP_PIN	= PA25
+)
+```
+
+USBCDC pins
+
+
+```go
+const (
+	UART_TX_PIN	= D1
+	UART_RX_PIN	= D0
+)
+```
+
+
+
+```go
+const (
+	UART2_TX_PIN	= A4
+	UART2_RX_PIN	= A5
+)
+```
+
+
+
+```go
+const (
+	SDA_PIN	= D22	// SDA: SERCOM2/PAD[0]
+	SCL_PIN	= D21	// SCL: SERCOM2/PAD[1]
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= D25	// SCK: SERCOM1/PAD[1]
+	SPI0_SDO_PIN	= D24	// SDO: SERCOM1/PAD[3]
+	SPI0_SDI_PIN	= D23	// SDI: SERCOM1/PAD[2]
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinAnalog		PinMode	= 1
+	PinSERCOM		PinMode	= 2
+	PinSERCOMAlt		PinMode	= 3
+	PinTimer		PinMode	= 4
+	PinTimerAlt		PinMode	= 5
+	PinTCCPDEC		PinMode	= 6
+	PinCom			PinMode	= 7
+	PinSDHC			PinMode	= 8
+	PinI2S			PinMode	= 9
+	PinPCC			PinMode	= 10
+	PinGMAC			PinMode	= 11
+	PinACCLK		PinMode	= 12
+	PinCCL			PinMode	= 13
+	PinDigital		PinMode	= 14
+	PinInput		PinMode	= 15
+	PinInputPullup		PinMode	= 16
+	PinOutput		PinMode	= 17
+	PinTCCE			PinMode	= PinTimer
+	PinTCCF			PinMode	= PinTimerAlt
+	PinTCCG			PinMode	= PinTCCPDEC
+	PinInputPulldown	PinMode	= 18
+	PinCAN			PinMode	= 19
+	PinCAN0			PinMode	= PinSDHC
+	PinCAN1			PinMode	= PinCom
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
+	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
+	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	PA00	Pin	= 0
+	PA01	Pin	= 1
+	PA02	Pin	= 2
+	PA03	Pin	= 3
+	PA04	Pin	= 4
+	PA05	Pin	= 5
+	PA06	Pin	= 6
+	PA07	Pin	= 7
+	PA08	Pin	= 8	// peripherals: TCC0 channel 0, TCC1 channel 4, sercomI2CM0 SDA, sercomI2CM2 SDA
+	PA09	Pin	= 9	// peripherals: TCC0 channel 1, TCC1 channel 5, sercomI2CM0 SCL, sercomI2CM2 SCL
+	PA10	Pin	= 10	// peripherals: TCC0 channel 2, TCC1 channel 6
+	PA11	Pin	= 11	// peripherals: TCC0 channel 3, TCC1 channel 7
+	PA12	Pin	= 12	// peripherals: TCC0 channel 6, TCC1 channel 2, sercomI2CM2 SDA, sercomI2CM4 SDA
+	PA13	Pin	= 13	// peripherals: TCC0 channel 7, TCC1 channel 3, sercomI2CM2 SCL, sercomI2CM4 SCL
+	PA14	Pin	= 14	// peripherals: TCC2 channel 0, TCC1 channel 2
+	PA15	Pin	= 15	// peripherals: TCC2 channel 1, TCC1 channel 3
+	PA16	Pin	= 16	// peripherals: TCC1 channel 0, TCC0 channel 4, sercomI2CM1 SDA, sercomI2CM3 SDA
+	PA17	Pin	= 17	// peripherals: TCC1 channel 1, TCC0 channel 5, sercomI2CM1 SCL, sercomI2CM3 SCL
+	PA18	Pin	= 18	// peripherals: TCC1 channel 2, TCC0 channel 6
+	PA19	Pin	= 19	// peripherals: TCC1 channel 3, TCC0 channel 7
+	PA20	Pin	= 20	// peripherals: TCC1 channel 4, TCC0 channel 0
+	PA21	Pin	= 21	// peripherals: TCC1 channel 5, TCC0 channel 1
+	PA22	Pin	= 22	// peripherals: TCC1 channel 6, TCC0 channel 2, sercomI2CM3 SDA, sercomI2CM5 SDA
+	PA23	Pin	= 23	// peripherals: TCC1 channel 7, TCC0 channel 3, sercomI2CM3 SCL, sercomI2CM5 SCL
+	PA24	Pin	= 24	// peripherals: TCC2 channel 2
+	PA25	Pin	= 25	// peripherals: TCC2 channel 3
+	PA26	Pin	= 26
+	PA27	Pin	= 27
+	PA28	Pin	= 28
+	PA29	Pin	= 29
+	PA30	Pin	= 30	// peripherals: TCC2 channel 0
+	PA31	Pin	= 31	// peripherals: TCC2 channel 1
+	PB00	Pin	= 32
+	PB01	Pin	= 33
+	PB02	Pin	= 34	// peripherals: TCC2 channel 2
+	PB03	Pin	= 35	// peripherals: TCC2 channel 3
+	PB04	Pin	= 36
+	PB05	Pin	= 37
+	PB06	Pin	= 38
+	PB07	Pin	= 39
+	PB08	Pin	= 40
+	PB09	Pin	= 41
+	PB10	Pin	= 42	// peripherals: TCC0 channel 4, TCC1 channel 0
+	PB11	Pin	= 43	// peripherals: TCC0 channel 5, TCC1 channel 1
+	PB12	Pin	= 44	// peripherals: TCC3 channel 0, TCC0 channel 0
+	PB13	Pin	= 45	// peripherals: TCC3 channel 1, TCC0 channel 1
+	PB14	Pin	= 46	// peripherals: TCC4 channel 0, TCC0 channel 2
+	PB15	Pin	= 47	// peripherals: TCC4 channel 1, TCC0 channel 3
+	PB16	Pin	= 48	// peripherals: TCC3 channel 0, TCC0 channel 4
+	PB17	Pin	= 49	// peripherals: TCC3 channel 1, TCC0 channel 5
+	PB18	Pin	= 50	// peripherals: TCC1 channel 0
+	PB19	Pin	= 51	// peripherals: TCC1 channel 1
+	PB20	Pin	= 52	// peripherals: TCC1 channel 2
+	PB21	Pin	= 53	// peripherals: TCC1 channel 3
+	PB22	Pin	= 54
+	PB23	Pin	= 55
+	PB24	Pin	= 56
+	PB25	Pin	= 57
+	PB26	Pin	= 58	// peripherals: TCC1 channel 2
+	PB27	Pin	= 59	// peripherals: TCC1 channel 3
+	PB28	Pin	= 60	// peripherals: TCC1 channel 4
+	PB29	Pin	= 61	// peripherals: TCC1 channel 5
+	PB30	Pin	= 62	// peripherals: TCC4 channel 0, TCC0 channel 6
+	PB31	Pin	= 63	// peripherals: TCC4 channel 1, TCC0 channel 7
+	PC00	Pin	= 64
+	PC01	Pin	= 65
+	PC02	Pin	= 66
+	PC03	Pin	= 67
+	PC04	Pin	= 68	// peripherals: TCC0 channel 0
+	PC05	Pin	= 69	// peripherals: TCC0 channel 1
+	PC06	Pin	= 70
+	PC07	Pin	= 71
+	PC08	Pin	= 72
+	PC09	Pin	= 73
+	PC10	Pin	= 74	// peripherals: TCC0 channel 0, TCC1 channel 4
+	PC11	Pin	= 75	// peripherals: TCC0 channel 1, TCC1 channel 5
+	PC12	Pin	= 76	// peripherals: TCC0 channel 2, TCC1 channel 6
+	PC13	Pin	= 77	// peripherals: TCC0 channel 3, TCC1 channel 7
+	PC14	Pin	= 78	// peripherals: TCC0 channel 4, TCC1 channel 0
+	PC15	Pin	= 79	// peripherals: TCC0 channel 5, TCC1 channel 1
+	PC16	Pin	= 80	// peripherals: TCC0 channel 0
+	PC17	Pin	= 81	// peripherals: TCC0 channel 1
+	PC18	Pin	= 82	// peripherals: TCC0 channel 2
+	PC19	Pin	= 83	// peripherals: TCC0 channel 3
+	PC20	Pin	= 84	// peripherals: TCC0 channel 4
+	PC21	Pin	= 85	// peripherals: TCC0 channel 5
+	PC22	Pin	= 86	// peripherals: TCC0 channel 6
+	PC23	Pin	= 87	// peripherals: TCC0 channel 7
+	PC24	Pin	= 88
+	PC25	Pin	= 89
+	PC26	Pin	= 90
+	PC27	Pin	= 91
+	PC28	Pin	= 92
+	PC29	Pin	= 93
+	PC30	Pin	= 94
+	PC31	Pin	= 95
+	PD00	Pin	= 96
+	PD01	Pin	= 97
+	PD02	Pin	= 98
+	PD03	Pin	= 99
+	PD04	Pin	= 100
+	PD05	Pin	= 101
+	PD06	Pin	= 102
+	PD07	Pin	= 103
+	PD08	Pin	= 104	// peripherals: TCC0 channel 1, sercomI2CM6 SDA, sercomI2CM7 SDA
+	PD09	Pin	= 105	// peripherals: TCC0 channel 2, sercomI2CM6 SCL, sercomI2CM7 SCL
+	PD10	Pin	= 106	// peripherals: TCC0 channel 3
+	PD11	Pin	= 107	// peripherals: TCC0 channel 4
+	PD12	Pin	= 108	// peripherals: TCC0 channel 5
+	PD13	Pin	= 109	// peripherals: TCC0 channel 6
+	PD14	Pin	= 110
+	PD15	Pin	= 111
+	PD16	Pin	= 112
+	PD17	Pin	= 113
+	PD18	Pin	= 114
+	PD19	Pin	= 115
+	PD20	Pin	= 116	// peripherals: TCC1 channel 0
+	PD21	Pin	= 117	// peripherals: TCC1 channel 1
+	PD22	Pin	= 118
+	PD23	Pin	= 119
+	PD24	Pin	= 120
+	PD25	Pin	= 121
+	PD26	Pin	= 122
+	PD27	Pin	= 123
+	PD28	Pin	= 124
+	PD29	Pin	= 125
+	PD30	Pin	= 126
+	PD31	Pin	= 127
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	// SERCOM_FREQ_REF is always reference frequency on SAMD51 regardless of CPU speed.
+	SERCOM_FREQ_REF		= 48000000
+	SERCOM_FREQ_REF_GCLK0	= 120000000
+
+	// Default rise time in nanoseconds, based on 4.7K ohm pull up resistors
+	riseTimeNanoseconds	= 125
+
+	// wire bus states
+	wireUnknownState	= 0
+	wireIdleState		= 1
+	wireOwnerState		= 2
+	wireBusyState		= 3
+
+	// wire commands
+	wireCmdNoAction		= 0
+	wireCmdRepeatStart	= 1
+	wireCmdRead		= 2
+	wireCmdStop		= 3
+)
+```
+
+
+
+```go
+const (
+	QSPI_SCK	= PB10
+	QSPI_CS		= PB11
+	QSPI_DATA0	= PA08
+	QSPI_DATA1	= PA09
+	QSPI_DATA2	= PA10
+	QSPI_DATA3	= PA11
+)
+```
+
+The QSPI peripheral on ATSAMD51 is only available on the following pins
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (16s)
+	WatchdogMaxTimeout = (16384 * 1000) / 1024	// CYC16384/1024kHz
+)
+```
+
+
+
+```go
+const (
+	// these are SAMD51 specific.
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Pos	= 0
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Mask	= 0x3FFF
+
+	usb_DEVICE_PCKSIZE_SIZE_Pos	= 28
+	usb_DEVICE_PCKSIZE_SIZE_Mask	= 0x7
+
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Pos	= 14
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Mask	= 0x3FFF
+
+	NumberOfUSBEndpoints	= 8
+)
+```
+
+
+
+```go
+const HSRAM_SIZE = 0x00030000
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	UART1	= &sercomUSART5
+	UART2	= &sercomUSART0
+
+	DefaultUART	= UART1
+)
+```
+
+
+
+```go
+var (
+	I2C0 = sercomI2CM2
+)
+```
+
+I2C on the Feather M4.
+
+
+```go
+var SPI0 = sercomSPIM1
+```
+
+SPI on the Feather M4.
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	DAC0	= DAC{Channel: 0}
+	DAC1	= DAC{Channel: 1}
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the SAMD51.
+
+
+```go
+var (
+	TCC0	= (*TCC)(sam.TCC0)
+	TCC1	= (*TCC)(sam.TCC1)
+	TCC2	= (*TCC)(sam.TCC2)
+	TCC3	= (*TCC)(sam.TCC3)
+	TCC4	= (*TCC)(sam.TCC4)
+)
+```
+
+This chip has five TCC peripherals, which have PWM as one feature.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) and 16 bytes (128 bits) are common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of cryptographically secure random data
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig)
+```
+
+Configure configures a ADCPin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type DAC
+
+```go
+type DAC struct {
+	Channel uint8
+}
+```
+
+DAC on the SAMD51.
+
+
+
+### func (DAC) Configure
+
+```go
+func (dac DAC) Configure(config DACConfig)
+```
+
+Configure the DAC.
+output pin must already be configured.
+
+
+### func (DAC) Set
+
+```go
+func (dac DAC) Set(value uint16) error
+```
+
+Set writes a single 16-bit value to the DAC.
+Since the ATSAMD51 only has a 12-bit DAC, the passed-in value will be scaled down.
+
+
+
+
+## type DACConfig
+
+```go
+type DACConfig struct {
+}
+```
+
+DACConfig placeholder for future expansion.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*sam.SERCOM_I2CM_Type
+	SERCOM	uint8
+}
+```
+
+I2C on the SAMD51.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteByte
+
+```go
+func (i2c *I2C) WriteByte(data byte) error
+```
+
+WriteByte writes a single byte to the I2C bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when configured as an input or as
+an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+### func (Pin) Toggle
+
+```go
+func (p Pin) Toggle()
+```
+
+Toggle switches an output pin from low to high or from high to low.
+Warning: only use this on an output pin!
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*sam.SERCOM_SPIM_Type
+	SERCOM	uint8
+}
+```
+
+SPI
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type TCC
+
+```go
+type TCC sam.TCC_Type
+```
+
+TCC is one timer peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this timer peripheral at
+once.
+
+
+
+### func (*TCC) Channel
+
+```go
+func (tcc *TCC) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin. Note that one channel may be
+shared between multiple pins, and so will have the same duty cycle. If this
+is not desirable, look for a different TCC or consider using a different pin.
+
+
+### func (*TCC) Configure
+
+```go
+func (tcc *TCC) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this TCC.
+
+
+### func (*TCC) Counter
+
+```go
+func (tcc *TCC) Counter() uint32
+```
+
+Counter returns the current counter value of the timer in this TCC
+peripheral. It may be useful for debugging.
+
+
+### func (*TCC) Set
+
+```go
+func (tcc *TCC) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle, in other words the fraction of time the channel output is high (or low
+when inverted). For example, to set it to a 25% duty cycle, use:
+
+	tcc.Set(channel, tcc.Top() / 4)
+
+tcc.Set(channel, 0) will set the output to low and tcc.Set(channel,
+tcc.Top()) will set the output to high, assuming the output isn't inverted.
+
+
+### func (*TCC) SetInverting
+
+```go
+func (tcc *TCC) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TCC) SetPeriod
+
+```go
+func (tcc *TCC) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this TCC peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the TCC peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TCC) Top
+
+```go
+func (tcc *TCC) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+tcc.Set (see tcc.Set for more information).
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*sam.SERCOM_USART_INT_Type
+	SERCOM		uint8
+	Interrupt	interrupt.Interrupt	// RXC interrupt
+}
+```
+
+UART on the SAMD51.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/feather-nrf52840-sense.md b/content/docs/reference/microcontrollers/machine/feather-nrf52840-sense.md
new file mode 100644
index 00000000..a82f5a8c
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/feather-nrf52840-sense.md
@@ -0,0 +1,1563 @@
+
+---
+title: feather-nrf52840-sense
+---
+
+
+## Constants
+
+```go
+const HasLowFrequencyCrystal = false
+```
+
+
+
+```go
+const (
+	D0	= P0_25	// UART TX
+	D1	= P0_24	// UART RX
+	D2	= P0_10	// NFC2
+	D3	= P1_11
+	D4	= P1_10	// LED2
+	D5	= P1_08
+	D6	= P0_07
+	D7	= P1_02	// Button
+	D8	= P0_16	// NeoPixel
+	D9	= P0_26
+	D10	= P0_27
+	D11	= P0_06
+	D12	= P0_08
+	D13	= P1_09	// LED1
+	D14	= P0_04	// A0
+	D15	= P0_05	// A1
+	D16	= P0_30	// A2
+	D17	= P0_28	// A3
+	D18	= P0_02	// A4
+	D19	= P0_03	// A5
+	D20	= P0_29	// Battery
+	D21	= P0_31	// AREF
+	D22	= P0_12	// I2C SDA
+	D23	= P0_11	// I2C SCL
+	D24	= P0_15	// SPI MISO
+	D25	= P0_13	// SPI MOSI
+	D26	= P0_14	// SPI SCK
+	D27	= P0_19	// QSPI CLK
+	D28	= P0_20	// QSPI CS
+	D29	= P0_17	// QSPI Data 0
+	D30	= P0_22	// QSPI Data 1
+	D31	= P0_23	// QSPI Data 2
+	D32	= P0_21	// QSPI Data 3
+	D33	= P0_09	// NFC1 (test point on bottom of board)
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A0	= D14
+	A1	= D15
+	A2	= D16
+	A3	= D17
+	A4	= D18
+	A5	= D19
+	A6	= D20	// Battery
+	A7	= D21	// ARef
+)
+```
+
+Analog Pins
+
+
+```go
+const (
+	LED		= D13
+	LED1		= LED
+	LED2		= D4
+	NEOPIXEL	= D8
+	WS2812		= D8
+	BUTTON		= D7
+
+	QSPI_SCK	= D27
+	QSPI_CS		= D28
+	QSPI_DATA0	= D29
+	QSPI_DATA1	= D30
+	QSPI_DATA2	= D31
+	QSPI_DATA3	= D32
+)
+```
+
+
+
+```go
+const (
+	UART_RX_PIN	= D1
+	UART_TX_PIN	= D0
+)
+```
+
+UART0 pins (logical UART1)
+
+
+```go
+const (
+	SDA_PIN	= D22	// I2C0 external
+	SCL_PIN	= D23	// I2C0 external
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= D26	// SCK
+	SPI0_SDO_PIN	= D25	// SDO
+	SPI0_SDI_PIN	= D24	// SDI
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	P0_00	Pin	= 0
+	P0_01	Pin	= 1
+	P0_02	Pin	= 2
+	P0_03	Pin	= 3
+	P0_04	Pin	= 4
+	P0_05	Pin	= 5
+	P0_06	Pin	= 6
+	P0_07	Pin	= 7
+	P0_08	Pin	= 8
+	P0_09	Pin	= 9
+	P0_10	Pin	= 10
+	P0_11	Pin	= 11
+	P0_12	Pin	= 12
+	P0_13	Pin	= 13
+	P0_14	Pin	= 14
+	P0_15	Pin	= 15
+	P0_16	Pin	= 16
+	P0_17	Pin	= 17
+	P0_18	Pin	= 18
+	P0_19	Pin	= 19
+	P0_20	Pin	= 20
+	P0_21	Pin	= 21
+	P0_22	Pin	= 22
+	P0_23	Pin	= 23
+	P0_24	Pin	= 24
+	P0_25	Pin	= 25
+	P0_26	Pin	= 26
+	P0_27	Pin	= 27
+	P0_28	Pin	= 28
+	P0_29	Pin	= 29
+	P0_30	Pin	= 30
+	P0_31	Pin	= 31
+	P1_00	Pin	= 32
+	P1_01	Pin	= 33
+	P1_02	Pin	= 34
+	P1_03	Pin	= 35
+	P1_04	Pin	= 36
+	P1_05	Pin	= 37
+	P1_06	Pin	= 38
+	P1_07	Pin	= 39
+	P1_08	Pin	= 40
+	P1_09	Pin	= 41
+	P1_10	Pin	= 42
+	P1_11	Pin	= 43
+	P1_12	Pin	= 44
+	P1_13	Pin	= 45
+	P1_14	Pin	= 46
+	P1_15	Pin	= 47
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
+	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
+	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 36h)
+	WatchdogMaxTimeout = (0xffffffff * 1000) / 32768
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	DefaultUART = UART0
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	// UART0 is the hardware UART on the NRF SoC.
+	_UART0	= UART{Buffer: NewRingBuffer()}
+	UART0	= &_UART0
+)
+```
+
+UART
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	PWM0	= &PWM{PWM: nrf.PWM0}
+	PWM1	= &PWM{PWM: nrf.PWM1}
+	PWM2	= &PWM{PWM: nrf.PWM2}
+	PWM3	= &PWM{PWM: nrf.PWM3}
+)
+```
+
+PWM
+
+
+```go
+var (
+	I2C0	= &I2C{Bus: nrf.TWIM0, BusT: nrf.TWIS0}
+	I2C1	= &I2C{Bus: nrf.TWIM1, BusT: nrf.TWIS1}
+)
+```
+
+There are 2 I2C interfaces on the NRF.
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	SPI0	= &SPI{Bus: nrf.SPIM0, buf: new([1]byte)}
+	SPI1	= &SPI{Bus: nrf.SPIM1, buf: new([1]byte)}
+	SPI2	= &SPI{Bus: nrf.SPIM2, buf: new([1]byte)}
+)
+```
+
+There are 3 SPI interfaces on the NRF528xx.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader resets the chip into the UF2 bootloader. After reset, it
+can be flashed via nrfutil or by copying a UF2 file to the mass storage device
+
+
+### func EnterOTABootloader
+
+```go
+func EnterOTABootloader()
+```
+
+EnterOTABootloader resets the chip into the bootloader so that it can be
+flashed via an OTA update
+
+
+### func EnterSerialBootloader
+
+```go
+func EnterSerialBootloader()
+```
+
+EnterSerialBootloader resets the chip into the serial bootloader. After
+reset, it can be flashed using serial/nrfutil.
+
+
+### func EnterUF2Bootloader
+
+```go
+func EnterUF2Bootloader()
+```
+
+EnterUF2Bootloader resets the chip into the UF2 bootloader. After reset, it
+can be flashed via nrfutil or by copying a UF2 file to the mass storage device
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (ret uint32, err error)
+```
+
+GetRNG returns 32 bits of non-deterministic random data based on internal thermal noise.
+According to Nordic's documentation, the random output is suitable for cryptographic purposes.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() int32
+```
+
+ReadTemperature reads the silicon die temperature of the chip. The return
+value is in milli-celsius.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USBHID (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (*ADC) Configure
+
+```go
+func (a *ADC) Configure(config ADCConfig)
+```
+
+Configure configures an ADC pin to be able to read analog data.
+Reference voltage can be 150, 300, 600, 1200, 1800, 2400, 3000(default), 3600 mV
+Resolution can be 8, 10, 12(default), 14 bits
+SampleTime will be ceiled to 3(default), 5, 10, 15, 20 or 40(max) µS respectively
+Samples can be 1(default), 2, 4, 8, 16, 32, 64, 128, 256 samples
+
+
+### func (*ADC) Get
+
+```go
+func (a *ADC) Get() uint16
+```
+
+Get returns the current value of an ADC pin in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*nrf.TWIM_Type	// Called Bus to align with Bus field in nrf51
+	BusT	*nrf.TWIS_Type
+	mode	I2CMode
+}
+```
+
+I2C on the NRF528xx.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint8) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+Reply supplies the response data the controller.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) (err error)
+```
+
+Tx does a single I2C transaction at the specified address (when in controller mode).
+
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+WaitForEvent blocks the current go-routine until an I2C event is received (when in Target mode).
+
+The passed buffer will be populated for receive events, with the number of bytes
+received returned in count.  For other event types, buf is not modified and a count
+of zero is returned.
+
+For request events, the caller MUST call `Reply` to avoid hanging the i2c bus indefinitely.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDM
+
+```go
+type PDM struct {
+	device		*nrf.PDM_Type
+	defaultBuffer	int16
+}
+```
+
+PDM represents a PDM device
+
+
+
+### func (*PDM) Configure
+
+```go
+func (pdm *PDM) Configure(config PDMConfig) error
+```
+
+Configure is intended to set up the PDM interface prior to use.
+
+
+### func (*PDM) Read
+
+```go
+func (pdm *PDM) Read(buf []int16) (uint32, error)
+```
+
+Read stores a set of samples in the given target buffer.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWM
+
+```go
+type PWM struct {
+	PWM	*nrf.PWM_Type
+
+	channelValues	[4]volatile.Register16
+}
+```
+
+PWM is one PWM peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this PWM peripheral at
+once.
+
+
+
+### func (*PWM) Channel
+
+```go
+func (pwm *PWM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*PWM) Configure
+
+```go
+func (pwm *PWM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+On the nRF52 series, the maximum period is around 0.26s.
+
+
+### func (*PWM) Set
+
+```go
+func (pwm *PWM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	ch.Set(ch.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*PWM) SetInverting
+
+```go
+func (pwm *PWM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*PWM) SetPeriod
+
+```go
+func (pwm *PWM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*PWM) Top
+
+```go
+func (pwm *PWM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*nrf.SPIM_Type
+	buf	*[1]byte	// 1-byte buffer for the Transfer method
+}
+```
+
+SPI on the NRF.
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to set up the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous
+write/read interface, there must always be the same number of bytes written
+as bytes read. Therefore, if the number of bytes don't match it will be
+padded until they fit: if len(w) > len(r) the extra bytes received will be
+dropped and if len(w) < len(r) extra 0 bytes will be sent.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer *RingBuffer
+}
+```
+
+UART on the NRF.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/feather-nrf52840.md b/content/docs/reference/microcontrollers/machine/feather-nrf52840.md
new file mode 100644
index 00000000..e23a2bec
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/feather-nrf52840.md
@@ -0,0 +1,1563 @@
+
+---
+title: feather-nrf52840
+---
+
+
+## Constants
+
+```go
+const HasLowFrequencyCrystal = true
+```
+
+
+
+```go
+const (
+	D0	= P0_25	// UART TX
+	D1	= P0_24	// UART RX
+	D2	= P0_10	// NFC2
+	D3	= P1_15	// LED1
+	D4	= P1_10	// LED2
+	D5	= P1_08
+	D6	= P0_07
+	D7	= P1_02	// Button
+	D8	= P0_16	// NeoPixel
+	D9	= P0_26
+	D10	= P0_27
+	D11	= P0_06
+	D12	= P0_08
+	D13	= P1_09
+	D14	= P0_04	// A0
+	D15	= P0_05	// A1
+	D16	= P0_30	// A2
+	D17	= P0_28	// A3
+	D18	= P0_02	// A4
+	D19	= P0_03	// A5
+	D20	= P0_29	// Battery
+	D21	= P0_31	// AREF
+	D22	= P0_12	// I2C SDA
+	D23	= P0_11	// I2C SCL
+	D24	= P0_15	// SPI MISO
+	D25	= P0_13	// SPI MOSI
+	D26	= P0_14	// SPI SCK
+	D27	= P0_19	// QSPI CLK
+	D28	= P0_20	// QSPI CS
+	D29	= P0_17	// QSPI Data 0
+	D30	= P0_22	// QSPI Data 1
+	D31	= P0_23	// QSPI Data 2
+	D32	= P0_21	// QSPI Data 3
+	D33	= P0_09	// NFC1 (test point on bottom of board)
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A0	= D14
+	A1	= D15
+	A2	= D16
+	A3	= D17
+	A4	= D18
+	A5	= D19
+	A6	= D20	// Battery
+	A7	= D21	// ARef
+)
+```
+
+Analog Pins
+
+
+```go
+const (
+	LED		= D3
+	LED1		= LED
+	LED2		= D4
+	NEOPIXEL	= D8
+	WS2812		= D8
+	BUTTON		= D7
+
+	QSPI_SCK	= D27
+	QSPI_CS		= D28
+	QSPI_DATA0	= D29
+	QSPI_DATA1	= D30
+	QSPI_DATA2	= D31
+	QSPI_DATA3	= D32
+)
+```
+
+
+
+```go
+const (
+	UART_RX_PIN	= D1
+	UART_TX_PIN	= D0
+)
+```
+
+UART0 pins (logical UART1)
+
+
+```go
+const (
+	SDA_PIN	= D22	// I2C0 external
+	SCL_PIN	= D23	// I2C0 external
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= D26	// SCK
+	SPI0_SDO_PIN	= D25	// SDO
+	SPI0_SDI_PIN	= D24	// SDI
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	P0_00	Pin	= 0
+	P0_01	Pin	= 1
+	P0_02	Pin	= 2
+	P0_03	Pin	= 3
+	P0_04	Pin	= 4
+	P0_05	Pin	= 5
+	P0_06	Pin	= 6
+	P0_07	Pin	= 7
+	P0_08	Pin	= 8
+	P0_09	Pin	= 9
+	P0_10	Pin	= 10
+	P0_11	Pin	= 11
+	P0_12	Pin	= 12
+	P0_13	Pin	= 13
+	P0_14	Pin	= 14
+	P0_15	Pin	= 15
+	P0_16	Pin	= 16
+	P0_17	Pin	= 17
+	P0_18	Pin	= 18
+	P0_19	Pin	= 19
+	P0_20	Pin	= 20
+	P0_21	Pin	= 21
+	P0_22	Pin	= 22
+	P0_23	Pin	= 23
+	P0_24	Pin	= 24
+	P0_25	Pin	= 25
+	P0_26	Pin	= 26
+	P0_27	Pin	= 27
+	P0_28	Pin	= 28
+	P0_29	Pin	= 29
+	P0_30	Pin	= 30
+	P0_31	Pin	= 31
+	P1_00	Pin	= 32
+	P1_01	Pin	= 33
+	P1_02	Pin	= 34
+	P1_03	Pin	= 35
+	P1_04	Pin	= 36
+	P1_05	Pin	= 37
+	P1_06	Pin	= 38
+	P1_07	Pin	= 39
+	P1_08	Pin	= 40
+	P1_09	Pin	= 41
+	P1_10	Pin	= 42
+	P1_11	Pin	= 43
+	P1_12	Pin	= 44
+	P1_13	Pin	= 45
+	P1_14	Pin	= 46
+	P1_15	Pin	= 47
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
+	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
+	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 36h)
+	WatchdogMaxTimeout = (0xffffffff * 1000) / 32768
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	DefaultUART = UART0
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	// UART0 is the hardware UART on the NRF SoC.
+	_UART0	= UART{Buffer: NewRingBuffer()}
+	UART0	= &_UART0
+)
+```
+
+UART
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	PWM0	= &PWM{PWM: nrf.PWM0}
+	PWM1	= &PWM{PWM: nrf.PWM1}
+	PWM2	= &PWM{PWM: nrf.PWM2}
+	PWM3	= &PWM{PWM: nrf.PWM3}
+)
+```
+
+PWM
+
+
+```go
+var (
+	I2C0	= &I2C{Bus: nrf.TWIM0, BusT: nrf.TWIS0}
+	I2C1	= &I2C{Bus: nrf.TWIM1, BusT: nrf.TWIS1}
+)
+```
+
+There are 2 I2C interfaces on the NRF.
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	SPI0	= &SPI{Bus: nrf.SPIM0, buf: new([1]byte)}
+	SPI1	= &SPI{Bus: nrf.SPIM1, buf: new([1]byte)}
+	SPI2	= &SPI{Bus: nrf.SPIM2, buf: new([1]byte)}
+)
+```
+
+There are 3 SPI interfaces on the NRF528xx.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader resets the chip into the UF2 bootloader. After reset, it
+can be flashed via nrfutil or by copying a UF2 file to the mass storage device
+
+
+### func EnterOTABootloader
+
+```go
+func EnterOTABootloader()
+```
+
+EnterOTABootloader resets the chip into the bootloader so that it can be
+flashed via an OTA update
+
+
+### func EnterSerialBootloader
+
+```go
+func EnterSerialBootloader()
+```
+
+EnterSerialBootloader resets the chip into the serial bootloader. After
+reset, it can be flashed using serial/nrfutil.
+
+
+### func EnterUF2Bootloader
+
+```go
+func EnterUF2Bootloader()
+```
+
+EnterUF2Bootloader resets the chip into the UF2 bootloader. After reset, it
+can be flashed via nrfutil or by copying a UF2 file to the mass storage device
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (ret uint32, err error)
+```
+
+GetRNG returns 32 bits of non-deterministic random data based on internal thermal noise.
+According to Nordic's documentation, the random output is suitable for cryptographic purposes.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() int32
+```
+
+ReadTemperature reads the silicon die temperature of the chip. The return
+value is in milli-celsius.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USBHID (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (*ADC) Configure
+
+```go
+func (a *ADC) Configure(config ADCConfig)
+```
+
+Configure configures an ADC pin to be able to read analog data.
+Reference voltage can be 150, 300, 600, 1200, 1800, 2400, 3000(default), 3600 mV
+Resolution can be 8, 10, 12(default), 14 bits
+SampleTime will be ceiled to 3(default), 5, 10, 15, 20 or 40(max) µS respectively
+Samples can be 1(default), 2, 4, 8, 16, 32, 64, 128, 256 samples
+
+
+### func (*ADC) Get
+
+```go
+func (a *ADC) Get() uint16
+```
+
+Get returns the current value of an ADC pin in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*nrf.TWIM_Type	// Called Bus to align with Bus field in nrf51
+	BusT	*nrf.TWIS_Type
+	mode	I2CMode
+}
+```
+
+I2C on the NRF528xx.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint8) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+Reply supplies the response data the controller.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) (err error)
+```
+
+Tx does a single I2C transaction at the specified address (when in controller mode).
+
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+WaitForEvent blocks the current go-routine until an I2C event is received (when in Target mode).
+
+The passed buffer will be populated for receive events, with the number of bytes
+received returned in count.  For other event types, buf is not modified and a count
+of zero is returned.
+
+For request events, the caller MUST call `Reply` to avoid hanging the i2c bus indefinitely.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDM
+
+```go
+type PDM struct {
+	device		*nrf.PDM_Type
+	defaultBuffer	int16
+}
+```
+
+PDM represents a PDM device
+
+
+
+### func (*PDM) Configure
+
+```go
+func (pdm *PDM) Configure(config PDMConfig) error
+```
+
+Configure is intended to set up the PDM interface prior to use.
+
+
+### func (*PDM) Read
+
+```go
+func (pdm *PDM) Read(buf []int16) (uint32, error)
+```
+
+Read stores a set of samples in the given target buffer.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWM
+
+```go
+type PWM struct {
+	PWM	*nrf.PWM_Type
+
+	channelValues	[4]volatile.Register16
+}
+```
+
+PWM is one PWM peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this PWM peripheral at
+once.
+
+
+
+### func (*PWM) Channel
+
+```go
+func (pwm *PWM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*PWM) Configure
+
+```go
+func (pwm *PWM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+On the nRF52 series, the maximum period is around 0.26s.
+
+
+### func (*PWM) Set
+
+```go
+func (pwm *PWM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	ch.Set(ch.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*PWM) SetInverting
+
+```go
+func (pwm *PWM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*PWM) SetPeriod
+
+```go
+func (pwm *PWM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*PWM) Top
+
+```go
+func (pwm *PWM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*nrf.SPIM_Type
+	buf	*[1]byte	// 1-byte buffer for the Transfer method
+}
+```
+
+SPI on the NRF.
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to set up the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous
+write/read interface, there must always be the same number of bytes written
+as bytes read. Therefore, if the number of bytes don't match it will be
+padded until they fit: if len(w) > len(r) the extra bytes received will be
+dropped and if len(w) < len(r) extra 0 bytes will be sent.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer *RingBuffer
+}
+```
+
+UART on the NRF.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/feather-rp2040.md b/content/docs/reference/microcontrollers/machine/feather-rp2040.md
new file mode 100644
index 00000000..68f6b675
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/feather-rp2040.md
@@ -0,0 +1,1688 @@
+
+---
+title: feather-rp2040
+---
+
+
+## Constants
+
+```go
+const (
+	D4	= GPIO6
+	D5	= GPIO7
+	D6	= GPIO8
+	D9	= GPIO9
+	D10	= GPIO10
+	D11	= GPIO11
+	D12	= GPIO12
+	D13	= GPIO13
+	D24	= GPIO24
+	D25	= GPIO25
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A0	= GPIO26
+	A1	= GPIO27
+	A2	= GPIO28
+	A3	= GPIO29
+)
+```
+
+Analog pins
+
+
+```go
+const LED = GPIO13
+```
+
+
+
+```go
+const (
+	I2C0_SDA_PIN	= GPIO24
+	I2C0_SCL_PIN	= GPIO25
+
+	I2C1_SDA_PIN	= GPIO2
+	I2C1_SCL_PIN	= GPIO3
+
+	SDA_PIN	= I2C1_SDA_PIN
+	SCL_PIN	= I2C1_SCL_PIN
+)
+```
+
+I2C Pins.
+
+
+```go
+const (
+	// Default Serial Clock Bus 0 for SPI communications
+	SPI0_SCK_PIN	= GPIO18
+	// Default Serial Out Bus 0 for SPI communications
+	SPI0_SDO_PIN	= GPIO19	// Tx
+	// Default Serial In Bus 0 for SPI communications
+	SPI0_SDI_PIN	= GPIO20	// Rx
+
+	// Default Serial Clock Bus 1 for SPI communications
+	SPI1_SCK_PIN	= GPIO10
+	// Default Serial Out Bus 1 for SPI communications
+	SPI1_SDO_PIN	= GPIO11	// Tx
+	// Default Serial In Bus 1 for SPI communications
+	SPI1_SDI_PIN	= GPIO12	// Rx
+)
+```
+
+SPI default pins
+
+
+```go
+const (
+	UART0_TX_PIN	= GPIO0
+	UART0_RX_PIN	= GPIO1
+	UART1_TX_PIN	= GPIO8
+	UART1_RX_PIN	= GPIO9
+	UART_TX_PIN	= UART0_TX_PIN
+	UART_RX_PIN	= UART0_RX_PIN
+)
+```
+
+UART pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	LS_SE0	= 0b00
+	LS_J	= 0b01
+	LS_K	= 0b10
+	LS_SE1	= 0b11
+)
+```
+
+
+
+```go
+const (
+	cpuFreq			= 200 * MHz
+	_NUMBANK0_GPIOS		= 30
+	_NUMBANK0_IRQS		= 4
+	_NUMIRQ			= 32
+	rp2350ExtraReg		= 0
+	RESETS_RESET_Msk	= 0x01ffffff
+	initUnreset		= rp.RESETS_RESET_ADC |
+		rp.RESETS_RESET_RTC |
+		rp.RESETS_RESET_SPI0 |
+		rp.RESETS_RESET_SPI1 |
+		rp.RESETS_RESET_UART0 |
+		rp.RESETS_RESET_UART1 |
+		rp.RESETS_RESET_USBCTRL
+	initDontReset	= rp.RESETS_RESET_IO_QSPI |
+		rp.RESETS_RESET_PADS_QSPI |
+		rp.RESETS_RESET_PLL_USB |
+		rp.RESETS_RESET_USBCTRL |
+		rp.RESETS_RESET_SYSCFG |
+		rp.RESETS_RESET_PLL_SYS
+	padEnableMask	= rp.PADS_BANK0_GPIO0_IE_Msk |
+		rp.PADS_BANK0_GPIO0_OD_Msk
+)
+```
+
+
+
+```go
+const (
+	PinOutput	PinMode	= iota
+	PinInput
+	PinInputPulldown
+	PinInputPullup
+	PinAnalog
+	PinUART
+	PinPWM
+	PinI2C
+	PinSPI
+	PinPIO0
+	PinPIO1
+)
+```
+
+
+
+```go
+const (
+	ADC0	Pin	= GPIO26
+	ADC1	Pin	= GPIO27
+	ADC2	Pin	= GPIO28
+	ADC3	Pin	= GPIO29
+
+	thermADC	= 30
+)
+```
+
+Analog pins on RP2040.
+
+
+```go
+const (
+	// Edge falling
+	PinFalling	PinChange	= 4 << iota
+	// Edge rising
+	PinRising
+
+	PinToggle	= PinFalling | PinRising
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// GPIO pins
+	GPIO0	Pin	= 0	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO1	Pin	= 1	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO2	Pin	= 2	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO3	Pin	= 3	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO4	Pin	= 4	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO5	Pin	= 5	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO6	Pin	= 6	// peripherals: PWM3 channel A, I2C1 SDA
+	GPIO7	Pin	= 7	// peripherals: PWM3 channel B, I2C1 SCL
+	GPIO8	Pin	= 8	// peripherals: PWM4 channel A, I2C0 SDA
+	GPIO9	Pin	= 9	// peripherals: PWM4 channel B, I2C0 SCL
+	GPIO10	Pin	= 10	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO11	Pin	= 11	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO12	Pin	= 12	// peripherals: PWM6 channel A, I2C0 SDA
+	GPIO13	Pin	= 13	// peripherals: PWM6 channel B, I2C0 SCL
+	GPIO14	Pin	= 14	// peripherals: PWM7 channel A, I2C1 SDA
+	GPIO15	Pin	= 15	// peripherals: PWM7 channel B, I2C1 SCL
+	GPIO16	Pin	= 16	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO17	Pin	= 17	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO18	Pin	= 18	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO19	Pin	= 19	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO20	Pin	= 20	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO21	Pin	= 21	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO22	Pin	= 22	// peripherals: PWM3 channel A
+	GPIO23	Pin	= 23	// peripherals: PWM3 channel B
+	GPIO24	Pin	= 24	// peripherals: PWM4 channel A
+	GPIO25	Pin	= 25	// peripherals: PWM4 channel B
+	GPIO26	Pin	= 26	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO27	Pin	= 27	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO28	Pin	= 28	// peripherals: PWM6 channel A
+	GPIO29	Pin	= 29	// peripherals: PWM6 channel B
+)
+```
+
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 8.3s).
+	//
+	// Nominal 1us per watchdog tick, 24-bit counter,
+	// but due to errata two ticks consumed per 1us.
+	// See: Errata RP2040-E1
+	WatchdogMaxTimeout = (rp.WATCHDOG_LOAD_LOAD_Msk / 1000) / 2
+)
+```
+
+
+
+```go
+const XOSC_STARTUP_DELAY_MULTIPLIER = 64
+```
+
+On some boards, the XOSC can take longer than usual to stabilize. On such
+boards, this is needed to avoid a hard fault on boot/reset. Refer to
+PICO_XOSC_STARTUP_DELAY_MULTIPLIER in the Pico SDK for additional details.
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	UART0	= &_UART0
+	_UART0	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART0,
+	}
+
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART1,
+	}
+)
+```
+
+UART on the RP2040
+
+
+```go
+var RTC = (*rtcType)(unsafe.Pointer(rp.RTC))
+```
+
+
+
+```go
+var (
+	ErrRtcDelayTooSmall	= errors.New("RTC interrupt deplay is too small, shall be at least 1 second")
+	ErrRtcDelayTooLarge	= errors.New("RTC interrupt deplay is too large, shall be no more than 1 day")
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	I2C0	= &_I2C0
+	_I2C0	= I2C{
+		Bus: rp.I2C0,
+	}
+	I2C1	= &_I2C1
+	_I2C1	= I2C{
+		Bus: rp.I2C1,
+	}
+)
+```
+
+I2C on the RP2040/RP2350
+
+
+```go
+var (
+	ErrBadPeriod = errors.New("period outside valid range 8ns..268ms")
+)
+```
+
+
+
+```go
+var (
+	PWM0	= getPWMGroup(0)
+	PWM1	= getPWMGroup(1)
+	PWM2	= getPWMGroup(2)
+	PWM3	= getPWMGroup(3)
+	PWM4	= getPWMGroup(4)
+	PWM5	= getPWMGroup(5)
+	PWM6	= getPWMGroup(6)
+	PWM7	= getPWMGroup(7)
+)
+```
+
+Hardware Pulse Width Modulation (PWM) API
+PWM peripherals available on RP2040. Each peripheral has 2 pins available for
+a total of 16 available PWM outputs. Some pins may not be available on some boards.
+
+The RP2040 PWM block has 8 identical slices. Each slice can drive two PWM output signals, or
+measure the frequency or duty cycle of an input signal. This gives a total of up to 16 controllable
+PWM outputs. All 30 GPIOs can be driven by the PWM block
+
+The PWM hardware functions by continuously comparing the input value to a free-running counter. This produces a
+toggling output where the amount of time spent at the high output level is proportional to the input value. The fraction of
+time spent at the high signal level is known as the duty cycle of the signal.
+
+The default behaviour of a PWM slice is to count upward until the wrap value (\ref pwm_config_set_wrap) is reached, and then
+immediately wrap to 0. PWM slices also offer a phase-correct mode, where the counter starts to count downward after
+reaching TOP, until it reaches 0 again.
+
+
+```go
+var (
+	SPI0	= &SPI{
+		Bus: rp.SPI0,
+	}
+	SPI1	= &SPI{
+		Bus: rp.SPI1,
+	}
+)
+```
+
+SPI on the RP2040
+
+
+```go
+var (
+	ErrLSBNotSupported	= errors.New("SPI LSB unsupported on PL022")
+	ErrSPITimeout		= errors.New("SPI timeout")
+	ErrSPIBaud		= errors.New("SPI baud too low or above 66.5Mhz")
+	errSPIInvalidSDI	= errors.New("invalid SPI SDI pin")
+	errSPIInvalidSDO	= errors.New("invalid SPI SDO pin")
+	errSPIInvalidSCK	= errors.New("invalid SPI SCK pin")
+)
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the RP2040.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ChipVersion
+
+```go
+func ChipVersion() uint8
+```
+
+ChipVersion returns the version of the chip. 1 is returned for B0 and B1
+chip.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func CurrentCore
+
+```go
+func CurrentCore() int
+```
+
+CurrentCore returns the core number the call was made from.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of semi-random data based on ring oscillator.
+
+Unlike some other implementations of GetRNG, these random numbers are not
+cryptographically secure and must not be used for cryptographic operations
+(nonces, etc).
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC resets the ADC peripheral.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func NumCores
+
+```go
+func NumCores() int
+```
+
+NumCores returns number of cores available on the device.
+
+
+### func PWMPeripheral
+
+```go
+func PWMPeripheral(pin Pin) (sliceNum uint8, err error)
+```
+
+Peripheral returns the RP2040 PWM peripheral which ranges from 0 to 7. Each
+PWM peripheral has 2 channels, A and B which correspond to 0 and 1 in the program.
+This number corresponds to the package's PWM0 throughout PWM7 handles
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() (millicelsius int32)
+```
+
+ReadTemperature does a one-shot sample of the internal temperature sensor and returns a milli-celsius reading.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig) error
+```
+
+Configure sets the ADC pin to analog input mode.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns a one-shot ADC sample reading.
+
+
+### func (ADC) GetADCChannel
+
+```go
+func (a ADC) GetADCChannel() (c ADCChannel, err error)
+```
+
+GetADCChannel returns the channel associated with the ADC pin.
+
+
+
+
+## type ADCChannel
+
+```go
+type ADCChannel uint8
+```
+
+ADCChannel is the ADC peripheral mux channel. 0-4.
+
+
+
+### func (ADCChannel) Configure
+
+```go
+func (c ADCChannel) Configure(config ADCConfig) error
+```
+
+Configure sets the channel's associated pin to analog input mode.
+The powered on temperature sensor increases ADC_AVDD current by approximately 40 μA.
+
+
+### func (ADCChannel) Pin
+
+```go
+func (c ADCChannel) Pin() (p Pin, err error)
+```
+
+The Pin method returns the GPIO Pin associated with the ADC mux channel, if it has one.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*rp.I2C0_Type
+	mode		I2CMode
+	txInProgress	bool
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure initializes i2c peripheral and configures I2C config's pins passed.
+Here's a list of valid SDA and SCL GPIO pins on bus I2C0 of the rp2040:
+
+	SDA: 0, 4, 8, 12, 16, 20
+	SCL: 1, 5, 9, 13, 17, 21
+
+Same as above for I2C1 bus:
+
+	SDA: 2, 6, 10, 14, 18, 26
+	SCL: 3, 7, 11, 15, 19, 27
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint16) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx performs a write and then a read transfer placing the result in
+in r.
+
+Passing a nil value for w or r skips the transfer corresponding to write
+or read, respectively.
+
+	i2c.Tx(addr, nil, r)
+
+Performs only a read transfer.
+
+	i2c.Tx(addr, w, nil)
+
+Performs only a write transfer.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	// SDA/SCL Serial Data and clock pins. Refer to datasheet to see
+	// which pins match the desired bus.
+	SDA, SCL	Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure configures the gpio pin as per mode.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get reads the pin value.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set drives the pin high if value is true else drives it low.
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+PinChange represents one or more trigger events that can happen on a given GPIO pin
+on the RP2040. ORed PinChanges are valid input to most IRQ functions.
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus *rp.SPI0_Type
+}
+```
+
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup/initialize the SPI interface.
+Default baudrate of 4MHz is used if Frequency == 0. Default
+word length (data bits) is 8.
+Below is a list of GPIO pins corresponding to SPI0 bus on the rp2040:
+
+	SI : 0, 4, 17  a.k.a RX and MISO (if rp2040 is master)
+	SO : 3, 7, 19  a.k.a TX and MOSI (if rp2040 is master)
+	SCK: 2, 6, 18
+
+SPI1 bus GPIO pins:
+
+	SI : 8, 12
+	SO : 11, 15
+	SCK: 10, 14
+
+No pin configuration is needed of SCK, SDO and SDI needed after calling Configure.
+
+
+### func (*SPI) GetBaudRate
+
+```go
+func (spi *SPI) GetBaudRate() uint32
+```
+
+
+
+### func (*SPI) PrintRegs
+
+```go
+func (spi *SPI) PrintRegs()
+```
+
+PrintRegs prints SPI's peripheral common registries current values
+
+
+### func (*SPI) SetBaudRate
+
+```go
+func (spi *SPI) SetBaudRate(br uint32) error
+```
+
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Write a single byte and read a single byte from TX/RX FIFO.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) (err error)
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+Remark: This implementation (RP2040) allows reading into buffer with a custom repeated
+value on tx.
+
+	spi.Tx([]byte{0xff}, rx) // may cause unwanted heap allocations.
+
+This form sends 0xff and puts the result into rx buffer. Useful for reading from SD cards
+which require 0xff input on SI.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	// LSB not supported on rp2040.
+	LSBFirst	bool
+	// Mode's two most LSB are CPOL and CPHA. i.e. Mode==2 (0b10) is CPOL=1, CPHA=0
+	Mode	uint8
+	// Serial clock pin
+	SCK	Pin
+	// TX or Serial Data Out (MOSI if rp2040 is master)
+	SDO	Pin
+	// RX or Serial Data In (MISO if rp2040 is master)
+	SDI	Pin
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*rp.UART0_Type
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the RP2040.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the baudrate to be used for the UART.
+
+
+### func (*UART) SetFormat
+
+```go
+func (uart *UART) SetFormat(databits, stopbits uint8, parity UARTParity) error
+```
+
+SetFormat for number of data bits, stop bits, and parity for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) ClearStallEPIn
+
+```go
+func (dev *USBDevice) ClearStallEPIn(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB IN endpoint.
+
+
+### func (*USBDevice) ClearStallEPOut
+
+```go
+func (dev *USBDevice) ClearStallEPOut(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB OUT endpoint.
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+### func (*USBDevice) SetStallEPIn
+
+```go
+func (dev *USBDevice) SetStallEPIn(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB IN endpoint.
+
+
+### func (*USBDevice) SetStallEPOut
+
+```go
+func (dev *USBDevice) SetStallEPOut(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB OUT endpoint.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/feather-stm32f405.md b/content/docs/reference/microcontrollers/machine/feather-stm32f405.md
new file mode 100644
index 00000000..6745cb53
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/feather-stm32f405.md
@@ -0,0 +1,1943 @@
+
+---
+title: feather-stm32f405
+---
+
+
+## Constants
+
+```go
+const (
+	NUM_DIGITAL_IO_PINS	= 39
+	NUM_ANALOG_IO_PINS	= 7
+)
+```
+
+
+
+```go
+const (
+	// Arduino pin = MCU port pin // primary functions (alternate functions)
+	D0	= PB11	// USART3 RX, PWM TIM2_CH4 (I2C2 SDA)
+	D1	= PB10	// USART3 TX, PWM TIM2_CH3 (I2C2 SCL, I2S2 BCK)
+	D2	= PB3	// GPIO, SPI3 FLASH SCK
+	D3	= PB4	// GPIO, SPI3 FLASH MISO
+	D4	= PB5	// GPIO, SPI3 FLASH MOSI
+	D5	= PC7	// GPIO, PWM TIM3_CH2 (USART6 RX, I2S3 MCK)
+	D6	= PC6	// GPIO, PWM TIM3_CH1 (USART6 TX, I2S2 MCK)
+	D7	= PA15	// GPIO, SPI3 FLASH CS
+	D8	= PC0	// GPIO, Neopixel
+	D9	= PB8	// GPIO, PWM TIM4_CH3 (CAN1 RX, I2C1 SCL)
+	D10	= PB9	// GPIO, PWM TIM4_CH4 (CAN1 TX, I2C1 SDA, I2S2 WSL)
+	D11	= PC3	// GPIO (I2S2 SD, SPI2 MOSI)
+	D12	= PC2	// GPIO (I2S2ext SD, SPI2 MISO)
+	D13	= PC1	// GPIO, Builtin LED
+	D14	= PB7	// I2C1 SDA, PWM TIM4_CH2 (USART1 RX)
+	D15	= PB6	// I2C1 SCL, PWM TIM4_CH1 (USART1 TX, CAN2 TX)
+	D16	= PA4	// A0 (DAC OUT1)
+	D17	= PA5	// A1 (DAC OUT2, SPI1 SCK)
+	D18	= PA6	// A2, PWM TIM3_CH1 (SPI1 MISO)
+	D19	= PA7	// A3, PWM TIM3_CH2 (SPI1 MOSI)
+	D20	= PC4	// A4
+	D21	= PC5	// A5
+	D22	= PA3	// A6
+	D23	= PB13	// SPI2 SCK, PWM TIM1_CH1N (I2S2 BCK, CAN2 TX)
+	D24	= PB14	// SPI2 MISO, PWM TIM1_CH2N (I2S2ext SD)
+	D25	= PB15	// SPI2 MOSI, PWM TIM1_CH3N (I2S2 SD)
+	D26	= PC8	// SDIO
+	D27	= PC9	// SDIO
+	D28	= PC10	// SDIO
+	D29	= PC11	// SDIO
+	D30	= PC12	// SDIO
+	D31	= PD2	// SDIO
+	D32	= PB12	// SD Detect
+	D33	= PC14	// OSC32
+	D34	= PC15	// OSC32
+	D35	= PA11	// USB D+
+	D36	= PA12	// USB D-
+	D37	= PA13	// SWDIO
+	D38	= PA14	// SWCLK
+)
+```
+
+Digital pins
+
+
+```go
+const (
+	A0	= D16	// ADC12 IN4
+	A1	= D17	// ADC12 IN5
+	A2	= D18	// ADC12 IN6
+	A3	= D19	// ADC12 IN7
+	A4	= D20	// ADC12 IN14
+	A5	= D21	// ADC12 IN15
+	A6	= D22	// VBAT
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	NUM_BOARD_LED		= 1
+	NUM_BOARD_NEOPIXEL	= 1
+
+	LED_RED		= D13
+	LED_NEOPIXEL	= D8
+	LED_BUILTIN	= LED_RED
+	LED		= LED_BUILTIN
+	WS2812		= D8
+)
+```
+
+
+
+```go
+const (
+	// #===========#==========#==============#============#=======#=======#
+	// | Interface | Hardware |  Bus(Freq)   | RX/TX Pins | AltFn | Alias |
+	// #===========#==========#==============#============#=======#=======#
+	// |   UART1   |  USART3  | APB1(42 MHz) |   D0/D1    |   7   |   ~   |
+	// |   UART2   |  USART6  | APB2(84 MHz) |   D5/D6    |   8   |   ~   |
+	// |   UART3   |  USART1  | APB2(84 MHz) |  D14/D15   |   7   |   ~   |
+	// | --------- | -------- | ------------ | ---------- | ----- | ----- |
+	// |   UART0   |  USART3  | APB1(42 MHz) |   D0/D1    |   7   | UART1 |
+	// #===========#==========#==============#============#=======#=======#
+	NUM_UART_INTERFACES	= 3
+
+	UART1_RX_PIN	= D0	// UART1 = hardware: USART3
+	UART1_TX_PIN	= D1	//
+
+	UART2_RX_PIN	= D5	// UART2 = hardware: USART6
+	UART2_TX_PIN	= D6	//
+
+	UART3_RX_PIN	= D14	// UART3 = hardware: USART1
+	UART3_TX_PIN	= D15	//
+
+	UART0_RX_PIN	= UART1_RX_PIN	// UART0 = alias: UART1
+	UART0_TX_PIN	= UART1_TX_PIN	//
+
+	UART_RX_PIN	= UART0_RX_PIN	// default/primary UART pins
+	UART_TX_PIN	= UART0_TX_PIN	//
+)
+```
+
+
+
+```go
+const (
+	// #===========#==========#==============#==================#=======#=======#
+	// | Interface | Hardware |  Bus(Freq)   | SCK/SDI/SDO Pins | AltFn | Alias |
+	// #===========#==========#==============#==================#=======#=======#
+	// |   SPI1    |   SPI2   | APB1(42 MHz) |    D23/D24/D25   |   5   |   ~   |
+	// |   SPI2    |   SPI3   | APB1(42 MHz) |     D2/D3/D4     |   6   |   ~   |
+	// |   SPI3    |   SPI1   | APB2(84 MHz) |    D17/D18/D19   |   5   |   ~   |
+	// | --------- | -------- | ------------ | ---------------- | ----- | ----- |
+	// |   SPI0    |   SPI2   | APB1(42 MHz) |    D23/D24/D25   |   5   | SPI1  |
+	// #===========#==========#==============#==================#=======#=======#
+	NUM_SPI_INTERFACES	= 3
+
+	SPI1_SCK_PIN	= D23	//
+	SPI1_SDI_PIN	= D24	// SPI1 = hardware: SPI2
+	SPI1_SDO_PIN	= D25	//
+
+	SPI2_SCK_PIN	= D2	//
+	SPI2_SDI_PIN	= D3	// SPI2 = hardware: SPI3
+	SPI2_SDO_PIN	= D4	//
+
+	SPI3_SCK_PIN	= D17	//
+	SPI3_SDI_PIN	= D18	// SPI3 = hardware: SPI1
+	SPI3_SDO_PIN	= D19	//
+
+	SPI0_SCK_PIN	= SPI1_SCK_PIN	//
+	SPI0_SDI_PIN	= SPI1_SDI_PIN	// SPI0 = alias: SPI1
+	SPI0_SDO_PIN	= SPI1_SDO_PIN	//
+
+	SPI_SCK_PIN	= SPI0_SCK_PIN	//
+	SPI_SDI_PIN	= SPI0_SDI_PIN	// default/primary SPI pins
+	SPI_SDO_PIN	= SPI0_SDO_PIN	//
+)
+```
+
+
+
+```go
+const (
+	// #===========#==========#==============#==============#=======#=======#
+	// | Interface | Hardware |  Bus(Freq)   | SDA/SCL Pins | AltFn | Alias |
+	// #===========#==========#==============#==============#=======#=======#
+	// |   I2C1    |   I2C1   | APB1(42 MHz) |   D14/D15    |   4   |   ~   |
+	// |   I2C2    |   I2C2   | APB1(42 MHz) |    D0/D1     |   4   |   ~   |
+	// |   I2C3    |   I2C1   | APB1(42 MHz) |    D9/D10    |   4   |   ~   |
+	// | --------- | -------- | ------------ | ------------ | ----- | ----- |
+	// |   I2C0    |   I2C1   | APB1(42 MHz) |   D14/D15    |   4   | I2C1  |
+	// #===========#==========#==============#==============#=======#=======#
+	NUM_I2C_INTERFACES	= 3
+
+	I2C1_SDA_PIN	= D14	// I2C1 = hardware: I2C1
+	I2C1_SCL_PIN	= D15	//
+
+	I2C2_SDA_PIN	= D0	// I2C2 = hardware: I2C2
+	I2C2_SCL_PIN	= D1	//
+
+	I2C3_SDA_PIN	= D9	// I2C3 = hardware: I2C1
+	I2C3_SCL_PIN	= D10	//   (interface duplicated on second pair of pins)
+
+	I2C0_SDA_PIN	= I2C1_SDA_PIN	// I2C0 = alias: I2C1
+	I2C0_SCL_PIN	= I2C1_SCL_PIN	//
+
+	I2C_SDA_PIN	= I2C0_SDA_PIN	// default/primary I2C pins
+	I2C_SCL_PIN	= I2C0_SCL_PIN	//
+
+	SDA_PIN	= I2C0_SDA_PIN
+	SCL_PIN	= I2C0_SCL_PIN
+)
+```
+
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinRising	PinChange	= 1 << iota
+	PinFalling
+	PinToggle	= PinRising | PinFalling
+)
+```
+
+
+
+```go
+const (
+	DutyCycle2	= 0
+	DutyCycle16x9	= 1
+)
+```
+
+I2C fast mode (Fm) duty cycle
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (32.768s)
+	//
+	// Timeout is based on 12-bit counter with /256 divider on
+	// 32.768kHz clock.  See 21.3.3 of RM0090 for table.
+	WatchdogMaxTimeout = ((0xfff + 1) * 256 * 1024) / 32768
+)
+```
+
+
+
+```go
+const (
+	// Mode Flag
+	PinOutput		PinMode	= 0
+	PinInput		PinMode	= PinInputFloating
+	PinInputFloating	PinMode	= 1
+	PinInputPulldown	PinMode	= 2
+	PinInputPullup		PinMode	= 3
+
+	// for UART
+	PinModeUARTTX	PinMode	= 4
+	PinModeUARTRX	PinMode	= 5
+
+	// for I2C
+	PinModeI2CSCL	PinMode	= 6
+	PinModeI2CSDA	PinMode	= 7
+
+	// for SPI
+	PinModeSPICLK	PinMode	= 8
+	PinModeSPISDO	PinMode	= 9
+	PinModeSPISDI	PinMode	= 10
+
+	// for analog/ADC
+	PinInputAnalog	PinMode	= 11
+
+	// for PWM
+	PinModePWMOutput	PinMode	= 12
+)
+```
+
+
+
+```go
+const RNG_MAX_READ_RETRIES = 1000
+```
+
+
+
+```go
+const PWM_MODE1 = 0x6
+```
+
+
+
+```go
+const (
+	PA0	= portA + 0
+	PA1	= portA + 1
+	PA2	= portA + 2
+	PA3	= portA + 3
+	PA4	= portA + 4
+	PA5	= portA + 5
+	PA6	= portA + 6
+	PA7	= portA + 7
+	PA8	= portA + 8
+	PA9	= portA + 9
+	PA10	= portA + 10
+	PA11	= portA + 11
+	PA12	= portA + 12
+	PA13	= portA + 13
+	PA14	= portA + 14
+	PA15	= portA + 15
+
+	PB0	= portB + 0
+	PB1	= portB + 1
+	PB2	= portB + 2
+	PB3	= portB + 3
+	PB4	= portB + 4
+	PB5	= portB + 5
+	PB6	= portB + 6
+	PB7	= portB + 7
+	PB8	= portB + 8
+	PB9	= portB + 9
+	PB10	= portB + 10
+	PB11	= portB + 11
+	PB12	= portB + 12
+	PB13	= portB + 13
+	PB14	= portB + 14
+	PB15	= portB + 15
+
+	PC0	= portC + 0
+	PC1	= portC + 1
+	PC2	= portC + 2
+	PC3	= portC + 3
+	PC4	= portC + 4
+	PC5	= portC + 5
+	PC6	= portC + 6
+	PC7	= portC + 7
+	PC8	= portC + 8
+	PC9	= portC + 9
+	PC10	= portC + 10
+	PC11	= portC + 11
+	PC12	= portC + 12
+	PC13	= portC + 13
+	PC14	= portC + 14
+	PC15	= portC + 15
+
+	PD0	= portD + 0
+	PD1	= portD + 1
+	PD2	= portD + 2
+	PD3	= portD + 3
+	PD4	= portD + 4
+	PD5	= portD + 5
+	PD6	= portD + 6
+	PD7	= portD + 7
+	PD8	= portD + 8
+	PD9	= portD + 9
+	PD10	= portD + 10
+	PD11	= portD + 11
+	PD12	= portD + 12
+	PD13	= portD + 13
+	PD14	= portD + 14
+	PD15	= portD + 15
+
+	PE0	= portE + 0
+	PE1	= portE + 1
+	PE2	= portE + 2
+	PE3	= portE + 3
+	PE4	= portE + 4
+	PE5	= portE + 5
+	PE6	= portE + 6
+	PE7	= portE + 7
+	PE8	= portE + 8
+	PE9	= portE + 9
+	PE10	= portE + 10
+	PE11	= portE + 11
+	PE12	= portE + 12
+	PE13	= portE + 13
+	PE14	= portE + 14
+	PE15	= portE + 15
+
+	PF0	= portF + 0
+	PF1	= portF + 1
+	PF2	= portF + 2
+	PF3	= portF + 3
+	PF4	= portF + 4
+	PF5	= portF + 5
+	PF6	= portF + 6
+	PF7	= portF + 7
+	PF8	= portF + 8
+	PF9	= portF + 9
+	PF10	= portF + 10
+	PF11	= portF + 11
+	PF12	= portF + 12
+	PF13	= portF + 13
+	PF14	= portF + 14
+	PF15	= portF + 15
+
+	PG0	= portG + 0
+	PG1	= portG + 1
+	PG2	= portG + 2
+	PG3	= portG + 3
+	PG4	= portG + 4
+	PG5	= portG + 5
+	PG6	= portG + 6
+	PG7	= portG + 7
+	PG8	= portG + 8
+	PG9	= portG + 9
+	PG10	= portG + 10
+	PG11	= portG + 11
+	PG12	= portG + 12
+	PG13	= portG + 13
+	PG14	= portG + 14
+	PG15	= portG + 15
+
+	PH0	= portH + 0
+	PH1	= portH + 1
+	PH2	= portH + 2
+	PH3	= portH + 3
+	PH4	= portH + 4
+	PH5	= portH + 5
+	PH6	= portH + 6
+	PH7	= portH + 7
+	PH8	= portH + 8
+	PH9	= portH + 9
+	PH10	= portH + 10
+	PH11	= portH + 11
+	PH12	= portH + 12
+	PH13	= portH + 13
+	PH14	= portH + 14
+	PH15	= portH + 15
+
+	PI0	= portI + 0
+	PI1	= portI + 1
+	PI2	= portI + 2
+	PI3	= portI + 3
+	PI4	= portI + 4
+	PI5	= portI + 5
+	PI6	= portI + 6
+	PI7	= portI + 7
+	PI8	= portI + 8
+	PI9	= portI + 9
+	PI10	= portI + 10
+	PI11	= portI + 11
+	PI12	= portI + 12
+	PI13	= portI + 13
+	PI14	= portI + 14
+	PI15	= portI + 15
+
+	PK0	= portK + 0
+	PK1	= portK + 1
+	PK2	= portK + 2
+	PK3	= portK + 3
+	PK4	= portK + 4
+	PK5	= portK + 5
+	PK6	= portK + 6
+	PK7	= portK + 7
+	PK8	= portK + 8
+	PK9	= portK + 9
+	PK10	= portK + 10
+	PK11	= portK + 11
+	PK12	= portK + 12
+	PK13	= portK + 13
+	PK14	= portK + 14
+	PK15	= portK + 15
+)
+```
+
+
+
+```go
+const (
+	ARR_MAX	= 0x10000
+	PSC_MAX	= 0x10000
+)
+```
+
+
+
+```go
+const (
+	AF0_SYSTEM			= 0
+	AF1_TIM1_2			= 1
+	AF2_TIM3_4_5			= 2
+	AF3_TIM8_9_10_11		= 3
+	AF4_I2C1_2_3			= 4
+	AF5_SPI1_SPI2			= 5
+	AF6_SPI3			= 6
+	AF7_USART1_2_3			= 7
+	AF8_USART4_5_6			= 8
+	AF9_CAN1_CAN2_TIM12_13_14	= 9
+	AF10_OTG_FS_OTG_HS		= 10
+	AF11_ETH			= 11
+	AF12_FSMC_SDIO_OTG_HS_1		= 12
+	AF13_DCMI			= 13
+	AF14				= 14
+	AF15_EVENTOUT			= 15
+)
+```
+
+Alternative peripheral pin functions
+
+
+```go
+const APB1_TIM_FREQ = 42000000 * 2
+```
+
+Internal use: configured speed of the APB1 and APB2 timers, this should be kept
+in sync with any changes to runtime package which configures the oscillators
+and clock frequencies
+
+
+```go
+const APB2_TIM_FREQ = 84000000 * 2
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:			NewRingBuffer(),
+		Bus:			stm32.USART3,
+		TxAltFuncSelector:	AF7_USART1_2_3,
+		RxAltFuncSelector:	AF7_USART1_2_3,
+	}
+	UART2	= &_UART2
+	_UART2	= UART{
+		Buffer:			NewRingBuffer(),
+		Bus:			stm32.USART6,
+		TxAltFuncSelector:	AF8_USART4_5_6,
+		RxAltFuncSelector:	AF8_USART4_5_6,
+	}
+	UART3	= &_UART3
+	_UART3	= UART{
+		Buffer:			NewRingBuffer(),
+		Bus:			stm32.USART1,
+		TxAltFuncSelector:	AF7_USART1_2_3,
+		RxAltFuncSelector:	AF7_USART1_2_3,
+	}
+	DefaultUART	= UART1
+)
+```
+
+
+
+```go
+var (
+	SPI1	= &SPI{
+		Bus:			stm32.SPI2,
+		AltFuncSelector:	AF5_SPI1_SPI2,
+	}
+	SPI2	= &SPI{
+		Bus:			stm32.SPI3,
+		AltFuncSelector:	AF6_SPI3,
+	}
+	SPI3	= &SPI{
+		Bus:			stm32.SPI1,
+		AltFuncSelector:	AF5_SPI1_SPI2,
+	}
+	SPI0	= SPI1
+)
+```
+
+
+
+```go
+var (
+	I2C1	= &I2C{
+		Bus:			stm32.I2C1,
+		AltFuncSelector:	AF4_I2C1_2_3,
+	}
+	I2C2	= &I2C{
+		Bus:			stm32.I2C2,
+		AltFuncSelector:	AF4_I2C1_2_3,
+	}
+	I2C3	= &I2C{
+		Bus:			stm32.I2C1,
+		AltFuncSelector:	AF4_I2C1_2_3,
+	}
+	I2C0	= I2C1
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	TIM1	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM1EN,
+		Device:		stm32.TIM1,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA8, AF1_TIM1_2}, {PE9, AF1_TIM1_2}}},
+			TimerChannel{Pins: []PinFunction{{PA9, AF1_TIM1_2}, {PE11, AF1_TIM1_2}}},
+			TimerChannel{Pins: []PinFunction{{PA10, AF1_TIM1_2}, {PE13, AF1_TIM1_2}}},
+			TimerChannel{Pins: []PinFunction{{PA11, AF1_TIM1_2}, {PE14, AF1_TIM1_2}}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM2	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM2EN,
+		Device:		stm32.TIM2,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA0, AF1_TIM1_2}, {PA5, AF1_TIM1_2}, {PA15, AF1_TIM1_2}}},
+			TimerChannel{Pins: []PinFunction{{PA1, AF1_TIM1_2}, {PB3, AF1_TIM1_2}}},
+			TimerChannel{Pins: []PinFunction{{PA2, AF1_TIM1_2}, {PB10, AF1_TIM1_2}}},
+			TimerChannel{Pins: []PinFunction{{PA3, AF1_TIM1_2}, {PB11, AF1_TIM1_2}}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM3	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM3EN,
+		Device:		stm32.TIM3,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA6, AF2_TIM3_4_5}, {PB4, AF2_TIM3_4_5}, {PC6, AF2_TIM3_4_5}}},
+			TimerChannel{Pins: []PinFunction{{PA7, AF2_TIM3_4_5}, {PB5, AF2_TIM3_4_5}, {PC7, AF2_TIM3_4_5}}},
+			TimerChannel{Pins: []PinFunction{{PB0, AF2_TIM3_4_5}, {PC8, AF2_TIM3_4_5}}},
+			TimerChannel{Pins: []PinFunction{{PB1, AF2_TIM3_4_5}, {PC9, AF2_TIM3_4_5}}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM4	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM4EN,
+		Device:		stm32.TIM4,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PB6, AF2_TIM3_4_5}, {PD12, AF2_TIM3_4_5}}},
+			TimerChannel{Pins: []PinFunction{{PB7, AF2_TIM3_4_5}, {PD13, AF2_TIM3_4_5}}},
+			TimerChannel{Pins: []PinFunction{{PB8, AF2_TIM3_4_5}, {PD14, AF2_TIM3_4_5}}},
+			TimerChannel{Pins: []PinFunction{{PB9, AF2_TIM3_4_5}, {PD15, AF2_TIM3_4_5}}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM5	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM5EN,
+		Device:		stm32.TIM5,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PH10, AF2_TIM3_4_5}}},
+			TimerChannel{Pins: []PinFunction{{PH11, AF2_TIM3_4_5}}},
+			TimerChannel{Pins: []PinFunction{{PH12, AF2_TIM3_4_5}}},
+			TimerChannel{Pins: []PinFunction{{PI0, AF2_TIM3_4_5}}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM6	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM6EN,
+		Device:		stm32.TIM6,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM7	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM7EN,
+		Device:		stm32.TIM7,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM8	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM8EN,
+		Device:		stm32.TIM8,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PC6, AF3_TIM8_9_10_11}, {PI5, AF3_TIM8_9_10_11}}},
+			TimerChannel{Pins: []PinFunction{{PC7, AF3_TIM8_9_10_11}, {PI6, AF3_TIM8_9_10_11}}},
+			TimerChannel{Pins: []PinFunction{{PC8, AF3_TIM8_9_10_11}, {PI7, AF3_TIM8_9_10_11}}},
+			TimerChannel{Pins: []PinFunction{{PC9, AF3_TIM8_9_10_11}, {PI2, AF3_TIM8_9_10_11}}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM9	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM9EN,
+		Device:		stm32.TIM9,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA2, AF3_TIM8_9_10_11}, {PE5, AF3_TIM8_9_10_11}}},
+			TimerChannel{Pins: []PinFunction{{PA3, AF3_TIM8_9_10_11}, {PE6, AF3_TIM8_9_10_11}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM10	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM10EN,
+		Device:		stm32.TIM10,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PB8, AF3_TIM8_9_10_11}, {PF6, AF3_TIM8_9_10_11}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM11	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM11EN,
+		Device:		stm32.TIM11,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PB9, AF3_TIM8_9_10_11}, {PF7, AF3_TIM8_9_10_11}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM12	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM12EN,
+		Device:		stm32.TIM12,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PB14, AF9_CAN1_CAN2_TIM12_13_14}, {PH6, AF9_CAN1_CAN2_TIM12_13_14}}},
+			TimerChannel{Pins: []PinFunction{{PB15, AF9_CAN1_CAN2_TIM12_13_14}, {PH9, AF9_CAN1_CAN2_TIM12_13_14}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM13	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM13EN,
+		Device:		stm32.TIM13,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA6, AF9_CAN1_CAN2_TIM12_13_14}, {PF8, AF9_CAN1_CAN2_TIM12_13_14}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM14	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM14EN,
+		Device:		stm32.TIM14,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA7, AF9_CAN1_CAN2_TIM12_13_14}, {PF9, AF9_CAN1_CAN2_TIM12_13_14}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+)
+```
+
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself.
+
+The length of the device ID for STM32 is 12 bytes (96 bits).
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of cryptographically secure random data
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC1.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(ADCConfig)
+```
+
+Configure configures an ADC pin to be able to read analog data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin in the range 0..0xffff.
+TODO: DMA based implementation.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type ChannelCallback
+
+```go
+type ChannelCallback func(channel uint8)
+```
+
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*stm32.I2C_Type
+	AltFuncSelector	uint8
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the STM32 I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+	DutyCycle	uint8
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration
+
+
+### func (Pin) ConfigureAltFunc
+
+```go
+func (p Pin) ConfigureAltFunc(config PinConfig, altFunc uint8)
+```
+
+Configure this pin with the given configuration including alternate
+
+	function mapping if necessary.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+PortMaskClear returns the register and mask to disable a given port. This can
+be used to implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+PortMaskSet returns the register and mask to enable a given GPIO pin. This
+can be used to implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetAltFunc
+
+```go
+func (p Pin) SetAltFunc(af uint8)
+```
+
+SetAltFunc maps the given alternative function to the I/O pin
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+---------- General pin operations ----------
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinFunction
+
+```go
+type PinFunction struct {
+	Pin	Pin
+	AltFunc	uint8
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus		*stm32.SPI_Type
+	AltFuncSelector	uint8
+}
+```
+
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the STM32 SPI1 interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type TIM
+
+```go
+type TIM struct {
+	EnableRegister	*volatile.Register32
+	EnableFlag	uint32
+	Device		*stm32.TIM_Type
+	Channels	[4]TimerChannel
+	UpInterrupt	interrupt.Interrupt
+	OCInterrupt	interrupt.Interrupt
+
+	wraparoundCallback	TimerCallback
+	channelCallbacks	[4]ChannelCallback
+
+	busFreq	uint64
+}
+```
+
+
+
+
+### func (*TIM) Channel
+
+```go
+func (t *TIM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*TIM) Configure
+
+```go
+func (t *TIM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+
+
+### func (*TIM) Count
+
+```go
+func (t *TIM) Count() uint32
+```
+
+
+
+### func (*TIM) Set
+
+```go
+func (t *TIM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	t.Set(ch, t.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*TIM) SetInverting
+
+```go
+func (t *TIM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TIM) SetMatchInterrupt
+
+```go
+func (t *TIM) SetMatchInterrupt(channel uint8, callback ChannelCallback) error
+```
+
+Sets a callback to be called when a channel reaches it's set-point.
+
+For example, if `t.Set(ch, t.Top() / 4)` is used then the callback will
+be called every quarter-period of the timer's base Period.
+
+
+### func (*TIM) SetPeriod
+
+```go
+func (t *TIM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TIM) SetWraparoundInterrupt
+
+```go
+func (t *TIM) SetWraparoundInterrupt(callback TimerCallback) error
+```
+
+SetWraparoundInterrupt configures a callback to be called each
+time the timer 'wraps-around'.
+
+For example, if `Configure(PWMConfig{Period:1000000})` is used,
+to set the timer period to 1ms, this callback will be called every
+1ms.
+
+
+### func (*TIM) Top
+
+```go
+func (t *TIM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+### func (*TIM) Unset
+
+```go
+func (t *TIM) Unset(channel uint8)
+```
+
+Unset disables a channel, including any configured interrupts.
+
+
+
+
+## type TimerCallback
+
+```go
+type TimerCallback func()
+```
+
+
+
+
+
+
+## type TimerChannel
+
+```go
+type TimerChannel struct {
+	Pins []PinFunction
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer			*RingBuffer
+	Bus			*stm32.USART_Type
+	Interrupt		interrupt.Interrupt
+	TxAltFuncSelector	uint8
+	RxAltFuncSelector	uint8
+
+	// Registers specific to the chip
+	rxReg		*volatile.Register32
+	txReg		*volatile.Register32
+	statusReg	*volatile.Register32
+	txEmptyFlag	uint32
+}
+```
+
+UART representation
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART. Defer to chip-specific
+routines for calculation
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/gameboy-advance.md b/content/docs/reference/microcontrollers/machine/gameboy-advance.md
new file mode 100644
index 00000000..9107885f
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/gameboy-advance.md
@@ -0,0 +1,446 @@
+
+---
+title: gameboy-advance
+---
+
+
+## Constants
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	IRQ_VBLANK	= gba.IRQ_VBLANK
+	IRQ_HBLANK	= gba.IRQ_HBLANK
+	IRQ_VCOUNT	= gba.IRQ_VCOUNT
+	IRQ_TIMER0	= gba.IRQ_TIMER0
+	IRQ_TIMER1	= gba.IRQ_TIMER1
+	IRQ_TIMER2	= gba.IRQ_TIMER2
+	IRQ_TIMER3	= gba.IRQ_TIMER3
+	IRQ_COM		= gba.IRQ_COM
+	IRQ_DMA0	= gba.IRQ_DMA0
+	IRQ_DMA1	= gba.IRQ_DMA1
+	IRQ_DMA2	= gba.IRQ_DMA2
+	IRQ_DMA3	= gba.IRQ_DMA3
+	IRQ_KEYPAD	= gba.IRQ_KEYPAD
+	IRQ_GAMEPAK	= gba.IRQ_GAMEPAK
+)
+```
+
+Interrupt numbers as used on the GameBoy Advance. Register them with
+runtime/interrupt.New.
+
+
+
+
+
+## Variables
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var Display = DisplayMode3{(*[160][240]volatile.Register16)(unsafe.Pointer(uintptr(gba.MEM_VRAM)))}
+```
+
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = NullSerial{}
+```
+
+Serial is a null device: writes to it are ignored.
+
+
+
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type DisplayMode3
+
+```go
+type DisplayMode3 struct {
+	port *[160][240]volatile.Register16
+}
+```
+
+
+
+
+### func (*DisplayMode3) Configure
+
+```go
+func (d *DisplayMode3) Configure()
+```
+
+
+
+### func (*DisplayMode3) Display
+
+```go
+func (d *DisplayMode3) Display() error
+```
+
+
+
+### func (*DisplayMode3) SetPixel
+
+```go
+func (d *DisplayMode3) SetPixel(x, y int16, c color.RGBA)
+```
+
+
+
+### func (*DisplayMode3) Size
+
+```go
+func (d *DisplayMode3) Size() (x, y int16)
+```
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set has not been implemented.
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/grandcentral-m4.md b/content/docs/reference/microcontrollers/machine/grandcentral-m4.md
new file mode 100644
index 00000000..9930f6a3
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/grandcentral-m4.md
@@ -0,0 +1,1843 @@
+
+---
+title: grandcentral-m4
+---
+
+
+## Constants
+
+```go
+const (
+	//  = Pin     Alt. Function        SERCOM   PWM Timer   Interrupt
+	//   ------  -------------------- -------- ----------- -----------
+	D0	= PB25	// UART1 RX              0[1]                 EXTI9
+	D1	= PB24	// UART1 TX              0[0]                 EXTI8
+	D2	= PC18	//                                TCC0[2]     EXTI2
+	D3	= PC19	//                                TCC0[3]     EXTI3
+	D4	= PC20	//                                TCC0[4]     EXTI4
+	D5	= PC21	//                                TCC0[5]     EXTI5
+	D6	= PD20	//                                TCC1[0]     EXTI10
+	D7	= PD21	//                                TCC1[1]     EXTI11
+	D8	= PB18	//                                TCC1[0]     EXTI2
+	D9	= PB02	//                                TC6[0]      EXTI3
+	D10	= PB22	//                                TC7[0]      EXTI6
+	D11	= PB23	//                                            EXTI7
+	D12	= PB00	//                                TC7[0]      EXTI0
+	D13	= PB01	// On-board LED                   TC7[1]      EXTI1
+	D14	= PB16	// UART4 TX, I2S0 SCK    5[0]     TC6[0]      EXTI0
+	D15	= PB17	// UART4 RX, I2S0 MCK    5[1]                 EXTI1
+	D16	= PC22	// UART3 TX              1[0]                 EXTI6
+	D17	= PC23	// UART3 RX              1[1]                 EXTI6
+	D18	= PB12	// UART2 TX              4[0]     TCC3[0]     EXTI12
+	D19	= PB13	// UART2 RX              4[1]     TCC3[1]     EXTI13
+	D20	= PB20	// I2C0 SDA              3[0]                 EXTI4
+	D21	= PB21	// I2C0 SCL              3[1]                 EXTI5
+	D22	= PD12	//                                            EXTI7
+	D23	= PA15	//                                TCC2[1]     EXTI15
+	D24	= PC17	// I2C1 SCL              6[1]     TCC0[1]     EXTI1
+	D25	= PC16	// I2C1 SDA              6[0]     TCC0[0]     EXTI0
+	D26	= PA12	// PCC DEN1                       TC2[0]      EXTI12
+	D27	= PA13	// PCC DEN2                       TC2[1]      EXTI13
+	D28	= PA14	// PCC CLK                        TCC2[0]     EXTI14
+	D29	= PB19	// PCC XCLK                                   EXTI3
+	D30	= PA23	// PCC D7                         TC4[1]      EXTI7
+	D31	= PA22	// PCC D6, I2S0 SDI               TC4[0]      EXTI6
+	D32	= PA21	// PCC D5, I2S0 SDO                           EXTI5
+	D33	= PA20	// PCC D4, I2S0 FS                            EXTI4
+	D34	= PA19	// PCC D3                         TC3[1]      EXTI3
+	D35	= PA18	// PCC D2                         TC3[0]      EXTI2
+	D36	= PA17	// PCC D1                                     EXTI1
+	D37	= PA16	// PCC D0                                     EXTI0
+	D38	= PB15	// PCC D9                         TCC4[1]     EXTI15
+	D39	= PB14	// PCC D8                         TCC4[0]     EXTI14
+	D40	= PC13	// PCC D11                                    EXTI13
+	D41	= PC12	// PCC D10                                    EXTI12
+	D42	= PC15	// PCC D13                                    EXTI15
+	D43	= PC14	// PCC D12                                    EXTI14
+	D44	= PC11	//                                            EXTI11
+	D45	= PC10	//                                            EXTI10
+	D46	= PC06	//                                            EXTI6
+	D47	= PC07	//                                            EXTI5
+	D48	= PC04	//                                            EXTI4
+	D49	= PC05	//                                            EXTI5
+	D50	= PD11	// SPI0 SDI              7[3]                 EXTI11
+	D51	= PD08	// SPI0 SDO              7[0]                 EXTI8
+	D52	= PD09	// SPI0 SCK              7[1]                 EXTI9
+	D53	= PD10	// SPI0 CS                                    EXTI10
+	D54	= PB05	// ADC1 (A8)                                  EXTI5
+	D55	= PB06	// ADC1 (A9)                                  EXTI6
+	D56	= PB07	// ADC1 (A10)                                 EXTI7
+	D57	= PB08	// ADC1 (A11)                                 EXTI8
+	D58	= PB09	// ADC1 (A12)                                 EXTI9
+	D59	= PA04	// ADC0 (A13)                     TC0[0]      EXTI4
+	D60	= PA06	// ADC0 (A14)                     TC1[0]      EXTI6
+	D61	= PA07	// ADC0 (A15)                     TC1[1]      EXTI7
+	D62	= PB20	// I2C0 SDA              3[0]     TCC1[2]     EXTI4
+	D63	= PB21	// I2C0 SCL              3[1]     TCC1[3]     EXTI5
+	D64	= PD11	// SPI0 SDI              7[3]                 EXTI6
+	D65	= PD08	// SPI0 SDO              7[0]                 EXTI3
+	D66	= PD09	// SPI0 SCK              7[1]                 EXTI4
+	D67	= PA02	// ADC0 (A0), DAC0                            EXTI2
+	D68	= PA05	// ADC0 (A1), DAC1                            EXTI5
+	D69	= PB03	// ADC0 (A2)                      TC6[1]      EXTI3
+	D70	= PC00	// ADC1 (A3)                                  EXTI0
+	D71	= PC01	// ADC1 (A4)                                  EXTI1
+	D72	= PC02	// ADC1 (A5)                                  EXTI2
+	D73	= PC03	// ADC1 (A6)                                  EXTI3
+	D74	= PB04	// ADC1 (A7)                                  EXTI4
+	D75	= PC31	// UART RX LED
+	D76	= PC30	// UART TX LED
+	D77	= PA27	// USB HOST EN
+	D78	= PA24	// USB DM                                     EXTI8
+	D79	= PA25	// USB DP                                     EXTI9
+	D80	= PB29	// SD/SPI1 SDI           2[3]
+	D81	= PB27	// SD/SPI1 SCK           2[1]
+	D82	= PB26	// SD/SPI1 SDO           2[0]
+	D83	= PB28	// SD/SPI1 CS
+	D84	= PA03	// AREF                                       EXTI3
+	D85	= PA02	// DAC0                                       EXTI2
+	D86	= PA05	// DAC1                                       EXTI5
+	D87	= PB01	// On-board LED (D13)             TC7[1]      EXTI1
+	D88	= PC24	// On-board NeoPixel
+	D89	= PB10	// QSPI SCK                                   EXTI10
+	D90	= PB11	// QSPI CS                                    EXTI11
+	D91	= PA08	// QSPI ID0                                   EXTI(NMI)
+	D92	= PA09	// QSPI ID1                                   EXTI9
+	D93	= PA10	// QSPI ID2                                   EXTI10
+	D94	= PA11	// QSPI ID3                                   EXTI11
+	D95	= PB31	// SD Detect                                  EXTI15
+	D96	= PB30	// SWO                                        EXTI14
+)
+```
+
+Digital pins
+
+
+```go
+const (
+	A0	= D67	// (PA02) ADC0 ch. 0,
+	A1	= D68	// (PA05) ADC0 ch. 5,
+	A2	= D69	// (PB03) ADC0 ch. 15
+	A3	= D70	// (PC00) ADC1 ch. 10
+	A4	= D71	// (PC01) ADC1 ch. 11
+	A5	= D72	// (PC02) ADC1 ch. 4
+	A6	= D73	// (PC03) ADC1 ch. 5
+	A7	= D74	// (PB04) ADC1 ch. 6
+	A8	= D54	// (PB05) ADC1 ch. 7
+	A9	= D55	// (PB06) ADC1 ch. 8
+	A10	= D56	// (PB07) ADC1 ch. 9
+	A11	= D57	// (PB08) ADC1 ch. 0
+	A12	= D58	// (PB09) ADC1 ch. 1
+	A13	= D59	// (PA04) ADC0 ch. 4
+	A14	= D60	// (PA06) ADC0 ch. 6
+	A15	= D61	// (PA07) ADC0 ch. 7
+
+	AREF	= D84	// (PA03)
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	LED_PIN		= D13	// (PB01), also on D87
+	UART_RX_LED_PIN	= D75	// (PC31)
+	UART_TX_LED_PIN	= D76	// (PC30)
+	NEOPIXEL_PIN	= D88	// (PC24)
+
+	// aliases used by examples and drivers
+	LED		= LED_PIN
+	LED_RX		= UART_RX_LED_PIN
+	LED_TX		= UART_TX_LED_PIN
+	NEOPIXEL	= NEOPIXEL_PIN
+	WS2812		= NEOPIXEL_PIN
+)
+```
+
+LED pins
+
+
+```go
+const (
+	UART1_RX_PIN	= D0	// (PB25)
+	UART1_TX_PIN	= D1	// (PB24)
+
+	UART2_RX_PIN	= D19	// (PB13)
+	UART2_TX_PIN	= D18	// (PB12)
+
+	UART3_RX_PIN	= D17	// (PC23)
+	UART3_TX_PIN	= D16	// (PC22)
+
+	UART4_RX_PIN	= D15	// (PB17)
+	UART4_TX_PIN	= D14	// (PB16)
+
+	UART_RX_PIN	= UART1_RX_PIN	// default pins
+	UART_TX_PIN	= UART1_TX_PIN	//
+)
+```
+
+UART pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= D66	// (PD09), also on D52
+	SPI0_SDO_PIN	= D65	// (PD08), also on D51
+	SPI0_SDI_PIN	= D64	// (PD11), also on D50
+	SPI0_CS_PIN	= D53	// (PD10)
+
+	SPI1_SCK_PIN	= D81	// (PB27)
+	SPI1_SDO_PIN	= D82	// (PB26)
+	SPI1_SDI_PIN	= D80	// (PB29)
+
+	SPI_SCK_PIN	= SPI0_SCK_PIN	// default pins
+	SPI_SDO_PIN	= SPI0_SDO_PIN	//
+	SPI_SDI_PIN	= SPI0_SDI_PIN	//
+	SPI_CS_PIN	= SPI0_CS_PIN	//
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	I2C0_SDA_PIN	= D62	// (PB20), also on D20
+	I2C0_SCL_PIN	= D63	// (PB21), also on D21
+
+	I2C1_SDA_PIN	= D25	// (PC16)
+	I2C1_SCL_PIN	= D24	// (PC17)
+
+	I2C_SDA_PIN	= I2C0_SDA_PIN	// default pins
+	I2C_SCL_PIN	= I2C0_SCL_PIN	//
+
+	SDA_PIN	= I2C_SDA_PIN	// unconventional pin names
+	SCL_PIN	= I2C_SCL_PIN	//  (required by machine_atsamd51.go)
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	I2S0_SCK_PIN	= D14	// (PB16)
+	I2S0_MCK_PIN	= D15	// (PB17)
+	I2S0_FS_PIN	= D33	// (PA20)
+	I2S0_SDO_PIN	= D32	// (PA21)
+	I2S0_SDI_PIN	= D31	// (PA22)
+
+	I2S_SCK_PIN	= I2S0_SCK_PIN	// default pins
+	I2S_WS_PIN	= I2S0_FS_PIN	//
+	I2S_SDO_PIN	= I2S0_SDO_PIN
+	I2S_SDI_PIN	= NoPin
+)
+```
+
+I2S pins
+
+
+```go
+const (
+	SD0_SCK_PIN	= D81	// (PB27)
+	SD0_SDO_PIN	= D82	// (PB26)
+	SD0_SDI_PIN	= D80	// (PB29)
+	SD0_CS_PIN	= D83	// (PB28)
+	SD0_DET_PIN	= D95	// (PB31)
+
+	SDCARD_SCK_PIN	= SD0_SCK_PIN	// default pins
+	SDCARD_SDO_PIN	= SD0_SDO_PIN	//
+	SDCARD_SDI_PIN	= SD0_SDI_PIN	//
+	SDCARD_CS_PIN	= SD0_CS_PIN	//
+	SDCARD_DET_PIN	= SD0_DET_PIN	//
+)
+```
+
+SD card pins
+
+
+```go
+const (
+	USBCDC_HOSTEN_PIN	= D77	// (PA27) host enable
+	USBCDC_DM_PIN		= D78	// (PA24) D-
+	USBCDC_DP_PIN		= D79	// (PA25) D+
+)
+```
+
+USB CDC pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinAnalog		PinMode	= 1
+	PinSERCOM		PinMode	= 2
+	PinSERCOMAlt		PinMode	= 3
+	PinTimer		PinMode	= 4
+	PinTimerAlt		PinMode	= 5
+	PinTCCPDEC		PinMode	= 6
+	PinCom			PinMode	= 7
+	PinSDHC			PinMode	= 8
+	PinI2S			PinMode	= 9
+	PinPCC			PinMode	= 10
+	PinGMAC			PinMode	= 11
+	PinACCLK		PinMode	= 12
+	PinCCL			PinMode	= 13
+	PinDigital		PinMode	= 14
+	PinInput		PinMode	= 15
+	PinInputPullup		PinMode	= 16
+	PinOutput		PinMode	= 17
+	PinTCCE			PinMode	= PinTimer
+	PinTCCF			PinMode	= PinTimerAlt
+	PinTCCG			PinMode	= PinTCCPDEC
+	PinInputPulldown	PinMode	= 18
+	PinCAN			PinMode	= 19
+	PinCAN0			PinMode	= PinSDHC
+	PinCAN1			PinMode	= PinCom
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
+	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
+	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	PA00	Pin	= 0
+	PA01	Pin	= 1
+	PA02	Pin	= 2
+	PA03	Pin	= 3
+	PA04	Pin	= 4
+	PA05	Pin	= 5
+	PA06	Pin	= 6
+	PA07	Pin	= 7
+	PA08	Pin	= 8	// peripherals: TCC0 channel 0, TCC1 channel 4, sercomI2CM0 SDA, sercomI2CM2 SDA
+	PA09	Pin	= 9	// peripherals: TCC0 channel 1, TCC1 channel 5, sercomI2CM0 SCL, sercomI2CM2 SCL
+	PA10	Pin	= 10	// peripherals: TCC0 channel 2, TCC1 channel 6
+	PA11	Pin	= 11	// peripherals: TCC0 channel 3, TCC1 channel 7
+	PA12	Pin	= 12	// peripherals: TCC0 channel 6, TCC1 channel 2, sercomI2CM2 SDA, sercomI2CM4 SDA
+	PA13	Pin	= 13	// peripherals: TCC0 channel 7, TCC1 channel 3, sercomI2CM2 SCL, sercomI2CM4 SCL
+	PA14	Pin	= 14	// peripherals: TCC2 channel 0, TCC1 channel 2
+	PA15	Pin	= 15	// peripherals: TCC2 channel 1, TCC1 channel 3
+	PA16	Pin	= 16	// peripherals: TCC1 channel 0, TCC0 channel 4, sercomI2CM1 SDA, sercomI2CM3 SDA
+	PA17	Pin	= 17	// peripherals: TCC1 channel 1, TCC0 channel 5, sercomI2CM1 SCL, sercomI2CM3 SCL
+	PA18	Pin	= 18	// peripherals: TCC1 channel 2, TCC0 channel 6
+	PA19	Pin	= 19	// peripherals: TCC1 channel 3, TCC0 channel 7
+	PA20	Pin	= 20	// peripherals: TCC1 channel 4, TCC0 channel 0
+	PA21	Pin	= 21	// peripherals: TCC1 channel 5, TCC0 channel 1
+	PA22	Pin	= 22	// peripherals: TCC1 channel 6, TCC0 channel 2, sercomI2CM3 SDA, sercomI2CM5 SDA
+	PA23	Pin	= 23	// peripherals: TCC1 channel 7, TCC0 channel 3, sercomI2CM3 SCL, sercomI2CM5 SCL
+	PA24	Pin	= 24	// peripherals: TCC2 channel 2
+	PA25	Pin	= 25	// peripherals: TCC2 channel 3
+	PA26	Pin	= 26
+	PA27	Pin	= 27
+	PA28	Pin	= 28
+	PA29	Pin	= 29
+	PA30	Pin	= 30	// peripherals: TCC2 channel 0
+	PA31	Pin	= 31	// peripherals: TCC2 channel 1
+	PB00	Pin	= 32
+	PB01	Pin	= 33
+	PB02	Pin	= 34	// peripherals: TCC2 channel 2
+	PB03	Pin	= 35	// peripherals: TCC2 channel 3
+	PB04	Pin	= 36
+	PB05	Pin	= 37
+	PB06	Pin	= 38
+	PB07	Pin	= 39
+	PB08	Pin	= 40
+	PB09	Pin	= 41
+	PB10	Pin	= 42	// peripherals: TCC0 channel 4, TCC1 channel 0
+	PB11	Pin	= 43	// peripherals: TCC0 channel 5, TCC1 channel 1
+	PB12	Pin	= 44	// peripherals: TCC3 channel 0, TCC0 channel 0
+	PB13	Pin	= 45	// peripherals: TCC3 channel 1, TCC0 channel 1
+	PB14	Pin	= 46	// peripherals: TCC4 channel 0, TCC0 channel 2
+	PB15	Pin	= 47	// peripherals: TCC4 channel 1, TCC0 channel 3
+	PB16	Pin	= 48	// peripherals: TCC3 channel 0, TCC0 channel 4
+	PB17	Pin	= 49	// peripherals: TCC3 channel 1, TCC0 channel 5
+	PB18	Pin	= 50	// peripherals: TCC1 channel 0
+	PB19	Pin	= 51	// peripherals: TCC1 channel 1
+	PB20	Pin	= 52	// peripherals: TCC1 channel 2
+	PB21	Pin	= 53	// peripherals: TCC1 channel 3
+	PB22	Pin	= 54
+	PB23	Pin	= 55
+	PB24	Pin	= 56
+	PB25	Pin	= 57
+	PB26	Pin	= 58	// peripherals: TCC1 channel 2
+	PB27	Pin	= 59	// peripherals: TCC1 channel 3
+	PB28	Pin	= 60	// peripherals: TCC1 channel 4
+	PB29	Pin	= 61	// peripherals: TCC1 channel 5
+	PB30	Pin	= 62	// peripherals: TCC4 channel 0, TCC0 channel 6
+	PB31	Pin	= 63	// peripherals: TCC4 channel 1, TCC0 channel 7
+	PC00	Pin	= 64
+	PC01	Pin	= 65
+	PC02	Pin	= 66
+	PC03	Pin	= 67
+	PC04	Pin	= 68	// peripherals: TCC0 channel 0
+	PC05	Pin	= 69	// peripherals: TCC0 channel 1
+	PC06	Pin	= 70
+	PC07	Pin	= 71
+	PC08	Pin	= 72
+	PC09	Pin	= 73
+	PC10	Pin	= 74	// peripherals: TCC0 channel 0, TCC1 channel 4
+	PC11	Pin	= 75	// peripherals: TCC0 channel 1, TCC1 channel 5
+	PC12	Pin	= 76	// peripherals: TCC0 channel 2, TCC1 channel 6
+	PC13	Pin	= 77	// peripherals: TCC0 channel 3, TCC1 channel 7
+	PC14	Pin	= 78	// peripherals: TCC0 channel 4, TCC1 channel 0
+	PC15	Pin	= 79	// peripherals: TCC0 channel 5, TCC1 channel 1
+	PC16	Pin	= 80	// peripherals: TCC0 channel 0
+	PC17	Pin	= 81	// peripherals: TCC0 channel 1
+	PC18	Pin	= 82	// peripherals: TCC0 channel 2
+	PC19	Pin	= 83	// peripherals: TCC0 channel 3
+	PC20	Pin	= 84	// peripherals: TCC0 channel 4
+	PC21	Pin	= 85	// peripherals: TCC0 channel 5
+	PC22	Pin	= 86	// peripherals: TCC0 channel 6
+	PC23	Pin	= 87	// peripherals: TCC0 channel 7
+	PC24	Pin	= 88
+	PC25	Pin	= 89
+	PC26	Pin	= 90
+	PC27	Pin	= 91
+	PC28	Pin	= 92
+	PC29	Pin	= 93
+	PC30	Pin	= 94
+	PC31	Pin	= 95
+	PD00	Pin	= 96
+	PD01	Pin	= 97
+	PD02	Pin	= 98
+	PD03	Pin	= 99
+	PD04	Pin	= 100
+	PD05	Pin	= 101
+	PD06	Pin	= 102
+	PD07	Pin	= 103
+	PD08	Pin	= 104	// peripherals: TCC0 channel 1, sercomI2CM6 SDA, sercomI2CM7 SDA
+	PD09	Pin	= 105	// peripherals: TCC0 channel 2, sercomI2CM6 SCL, sercomI2CM7 SCL
+	PD10	Pin	= 106	// peripherals: TCC0 channel 3
+	PD11	Pin	= 107	// peripherals: TCC0 channel 4
+	PD12	Pin	= 108	// peripherals: TCC0 channel 5
+	PD13	Pin	= 109	// peripherals: TCC0 channel 6
+	PD14	Pin	= 110
+	PD15	Pin	= 111
+	PD16	Pin	= 112
+	PD17	Pin	= 113
+	PD18	Pin	= 114
+	PD19	Pin	= 115
+	PD20	Pin	= 116	// peripherals: TCC1 channel 0
+	PD21	Pin	= 117	// peripherals: TCC1 channel 1
+	PD22	Pin	= 118
+	PD23	Pin	= 119
+	PD24	Pin	= 120
+	PD25	Pin	= 121
+	PD26	Pin	= 122
+	PD27	Pin	= 123
+	PD28	Pin	= 124
+	PD29	Pin	= 125
+	PD30	Pin	= 126
+	PD31	Pin	= 127
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	// SERCOM_FREQ_REF is always reference frequency on SAMD51 regardless of CPU speed.
+	SERCOM_FREQ_REF		= 48000000
+	SERCOM_FREQ_REF_GCLK0	= 120000000
+
+	// Default rise time in nanoseconds, based on 4.7K ohm pull up resistors
+	riseTimeNanoseconds	= 125
+
+	// wire bus states
+	wireUnknownState	= 0
+	wireIdleState		= 1
+	wireOwnerState		= 2
+	wireBusyState		= 3
+
+	// wire commands
+	wireCmdNoAction		= 0
+	wireCmdRepeatStart	= 1
+	wireCmdRead		= 2
+	wireCmdStop		= 3
+)
+```
+
+
+
+```go
+const (
+	QSPI_SCK	= PB10
+	QSPI_CS		= PB11
+	QSPI_DATA0	= PA08
+	QSPI_DATA1	= PA09
+	QSPI_DATA2	= PA10
+	QSPI_DATA3	= PA11
+)
+```
+
+The QSPI peripheral on ATSAMD51 is only available on the following pins
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (16s)
+	WatchdogMaxTimeout = (16384 * 1000) / 1024	// CYC16384/1024kHz
+)
+```
+
+
+
+```go
+const (
+	// these are SAMD51 specific.
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Pos	= 0
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Mask	= 0x3FFF
+
+	usb_DEVICE_PCKSIZE_SIZE_Pos	= 28
+	usb_DEVICE_PCKSIZE_SIZE_Mask	= 0x7
+
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Pos	= 14
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Mask	= 0x3FFF
+
+	NumberOfUSBEndpoints	= 8
+)
+```
+
+
+
+```go
+const HSRAM_SIZE = 0x00040000
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	UART1	= &sercomUSART0
+	UART2	= &sercomUSART4
+	UART3	= &sercomUSART1
+	UART4	= &sercomUSART5
+
+	DefaultUART	= UART1
+)
+```
+
+UART on the Grand Central M4
+
+
+```go
+var (
+	SPI0	= sercomSPIM7
+	SPI1	= sercomSPIM2	// SD card
+)
+```
+
+SPI on the Grand Central M4
+
+
+```go
+var (
+	I2C0	= sercomI2CM3
+	I2C1	= sercomI2CM6
+)
+```
+
+I2C on the Grand Central M4
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	DAC0	= DAC{Channel: 0}
+	DAC1	= DAC{Channel: 1}
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the SAMD51.
+
+
+```go
+var (
+	TCC0	= (*TCC)(sam.TCC0)
+	TCC1	= (*TCC)(sam.TCC1)
+	TCC2	= (*TCC)(sam.TCC2)
+	TCC3	= (*TCC)(sam.TCC3)
+	TCC4	= (*TCC)(sam.TCC4)
+)
+```
+
+This chip has five TCC peripherals, which have PWM as one feature.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) and 16 bytes (128 bits) are common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of cryptographically secure random data
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig)
+```
+
+Configure configures a ADCPin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type DAC
+
+```go
+type DAC struct {
+	Channel uint8
+}
+```
+
+DAC on the SAMD51.
+
+
+
+### func (DAC) Configure
+
+```go
+func (dac DAC) Configure(config DACConfig)
+```
+
+Configure the DAC.
+output pin must already be configured.
+
+
+### func (DAC) Set
+
+```go
+func (dac DAC) Set(value uint16) error
+```
+
+Set writes a single 16-bit value to the DAC.
+Since the ATSAMD51 only has a 12-bit DAC, the passed-in value will be scaled down.
+
+
+
+
+## type DACConfig
+
+```go
+type DACConfig struct {
+}
+```
+
+DACConfig placeholder for future expansion.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*sam.SERCOM_I2CM_Type
+	SERCOM	uint8
+}
+```
+
+I2C on the SAMD51.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteByte
+
+```go
+func (i2c *I2C) WriteByte(data byte) error
+```
+
+WriteByte writes a single byte to the I2C bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when configured as an input or as
+an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+### func (Pin) Toggle
+
+```go
+func (p Pin) Toggle()
+```
+
+Toggle switches an output pin from low to high or from high to low.
+Warning: only use this on an output pin!
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*sam.SERCOM_SPIM_Type
+	SERCOM	uint8
+}
+```
+
+SPI
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type TCC
+
+```go
+type TCC sam.TCC_Type
+```
+
+TCC is one timer peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this timer peripheral at
+once.
+
+
+
+### func (*TCC) Channel
+
+```go
+func (tcc *TCC) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin. Note that one channel may be
+shared between multiple pins, and so will have the same duty cycle. If this
+is not desirable, look for a different TCC or consider using a different pin.
+
+
+### func (*TCC) Configure
+
+```go
+func (tcc *TCC) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this TCC.
+
+
+### func (*TCC) Counter
+
+```go
+func (tcc *TCC) Counter() uint32
+```
+
+Counter returns the current counter value of the timer in this TCC
+peripheral. It may be useful for debugging.
+
+
+### func (*TCC) Set
+
+```go
+func (tcc *TCC) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle, in other words the fraction of time the channel output is high (or low
+when inverted). For example, to set it to a 25% duty cycle, use:
+
+	tcc.Set(channel, tcc.Top() / 4)
+
+tcc.Set(channel, 0) will set the output to low and tcc.Set(channel,
+tcc.Top()) will set the output to high, assuming the output isn't inverted.
+
+
+### func (*TCC) SetInverting
+
+```go
+func (tcc *TCC) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TCC) SetPeriod
+
+```go
+func (tcc *TCC) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this TCC peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the TCC peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TCC) Top
+
+```go
+func (tcc *TCC) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+tcc.Set (see tcc.Set for more information).
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*sam.SERCOM_USART_INT_Type
+	SERCOM		uint8
+	Interrupt	interrupt.Interrupt	// RXC interrupt
+}
+```
+
+UART on the SAMD51.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/microcontrollers/machine/hifive1b.md b/content/docs/reference/microcontrollers/machine/hifive1b.md
similarity index 51%
rename from content/microcontrollers/machine/hifive1b.md
rename to content/docs/reference/microcontrollers/machine/hifive1b.md
index 6955b0ba..b2e895e5 100644
--- a/content/microcontrollers/machine/hifive1b.md
+++ b/content/docs/reference/microcontrollers/machine/hifive1b.md
@@ -20,8 +20,8 @@ const (
 	P09	Pin	= 9
 	P10	Pin	= 10
 	P11	Pin	= 11
-	P12	Pin	= 12
-	P13	Pin	= 13
+	P12	Pin	= 12	// peripherals: I2C0 SDA
+	P13	Pin	= 13	// peripherals: I2C0 SCL
 	P14	Pin	= 14
 	P15	Pin	= 15
 	P16	Pin	= 16
@@ -130,6 +130,61 @@ const (
 
 TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
 
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
 
 ```go
 const NoPin = Pin(0xff)
@@ -163,35 +218,51 @@ const (
 SPI phase and polarity configs CPOL and CPHA
 
 
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
 
 
 
 ## Variables
 
 ```go
-var (
-	SPI1 = SPI{
-		Bus: sifive.QSPI1,
-	}
-)
+var DefaultUART = UART0
 ```
 
-SPI on the HiFive1.
 
 
 ```go
 var (
-	I2C0 = I2C{
-		Bus: sifive.I2C0,
+	SPI1 = &SPI{
+		Bus: sifive.QSPI1,
 	}
 )
 ```
 
-I2C on the HiFive1 rev B.
+SPI on the HiFive1.
 
 
 ```go
 var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
 	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
 	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
 	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
@@ -204,7 +275,8 @@ var (
 
 ```go
 var (
-	UART0 = UART{Bus: sifive.UART0, Buffer: NewRingBuffer()}
+	UART0	= &_UART0
+	_UART0	= UART{Bus: sifive.UART0, Buffer: NewRingBuffer()}
 )
 ```
 
@@ -212,7 +284,31 @@ var (
 
 ```go
 var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
+	I2C0 = (*I2C)(unsafe.Pointer(sifive.I2C0))
+)
+```
+
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
 )
 ```
 
@@ -229,6 +325,14 @@ func CPUFrequency() uint32
 
 
 
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
 ### func NewRingBuffer
 
 ```go
@@ -253,11 +357,29 @@ type ADC struct {
 
 
 
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
 ## type I2C
 
 ```go
 type I2C struct {
-	Bus *sifive.I2C_Type
+	Bus sifive.I2C_Type
 }
 ```
 
@@ -265,19 +387,19 @@ I2C on the FE310-G002.
 
 
 
-### func (I2C) Configure
+### func (*I2C) Configure
 
 ```go
-func (i2c I2C) Configure(config I2CConfig) error
+func (i2c *I2C) Configure(config I2CConfig) error
 ```
 
 Configure is intended to setup the I2C interface.
 
 
-### func (I2C) ReadRegister
+### func (*I2C) ReadRegister
 
 ```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
 ```
 
 ReadRegister transmits the register, restarts the connection as a read
@@ -288,10 +410,19 @@ is a shortcut to easily read such registers. Also, it only works for devices
 with 7-bit addresses, which is the vast majority.
 
 
-### func (I2C) Tx
+### func (*I2C) SetBaudRate
 
 ```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
 ```
 
 Tx does a single I2C transaction at the specified address.
@@ -299,10 +430,10 @@ It clocks out the given address, writes the bytes in w, reads back len(r)
 bytes and stores them in r, and generates a stop condition on the bus.
 
 
-### func (I2C) WriteRegister
+### func (*I2C) WriteRegister
 
 ```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
 ```
 
 WriteRegister transmits first the register and then the data to the
@@ -331,14 +462,124 @@ I2CConfig is used to store config info for I2C.
 
 
 
-## type PWM
+## type I2CMode
 
 ```go
-type PWM struct {
-	Pin Pin
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
 }
 ```
 
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
 
 
 
@@ -371,7 +612,8 @@ Configure this pin with the given configuration.
 func (p Pin) Get() bool
 ```
 
-Get returns the current value of a GPIO pin.
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
 
 
 ### func (Pin) High
@@ -396,6 +638,30 @@ pin. It is hardware dependent (and often undefined) what happens if you set a
 pin to low that is not configured as an output pin.
 
 
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+Warning: only use this on an output pin!
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+Warning: only use this on an output pin!
+
+
 ### func (Pin) Set
 
 ```go
@@ -426,6 +692,9 @@ type PinConfig struct {
 type PinMode uint8
 ```
 
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
 
 
 
@@ -499,47 +768,47 @@ to use SPI1 or SPI2 port for most applications.
 
 
 
-### func (SPI) Configure
+### func (*SPI) Configure
 
 ```go
-func (spi SPI) Configure(config SPIConfig) error
+func (spi *SPI) Configure(config SPIConfig) error
 ```
 
 Configure is intended to setup the SPI interface.
 
 
-### func (SPI) Transfer
+### func (*SPI) Transfer
 
 ```go
-func (spi SPI) Transfer(w byte) (byte, error)
+func (spi *SPI) Transfer(w byte) (byte, error)
 ```
 
 Transfer writes/reads a single byte using the SPI interface.
 
 
-### func (SPI) Tx
+### func (*SPI) Tx
 
 ```go
-func (spi SPI) Tx(w, r []byte) error
+func (spi *SPI) Tx(w, r []byte) error
 ```
 
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
 interface, there must always be the same number of bytes written as bytes read.
 The Tx method knows about this, and offers a few different ways of calling it.
 
 This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
 Note that the tx and rx buffers must be the same size:
 
-		spi.Tx(tx, rx)
+	spi.Tx(tx, rx)
 
 This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
 until all the bytes in the command packet have been received:
 
-		spi.Tx(tx, nil)
+	spi.Tx(tx, nil)
 
 This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
 
-		spi.Tx(nil, rx)
+	spi.Tx(nil, rx)
 
 
 
@@ -575,67 +844,70 @@ type UART struct {
 
 
 
-### func (UART) Buffered
+### func (*UART) Buffered
 
 ```go
-func (uart UART) Buffered() int
+func (uart *UART) Buffered() int
 ```
 
 Buffered returns the number of bytes currently stored in the RX buffer.
 
 
-### func (UART) Configure
+### func (*UART) Configure
 
 ```go
-func (uart UART) Configure(config UARTConfig)
+func (uart *UART) Configure(config UARTConfig)
 ```
 
 
 
-### func (UART) Read
+### func (*UART) Read
 
 ```go
-func (uart UART) Read(data []byte) (n int, err error)
+func (uart *UART) Read(data []byte) (n int, err error)
 ```
 
 Read from the RX buffer.
 
 
-### func (UART) ReadByte
+### func (*UART) ReadByte
 
 ```go
-func (uart UART) ReadByte() (byte, error)
+func (uart *UART) ReadByte() (byte, error)
 ```
 
 ReadByte reads a single byte from the RX buffer.
 If there is no data in the buffer, returns an error.
 
 
-### func (UART) Receive
+### func (*UART) Receive
 
 ```go
-func (uart UART) Receive(data byte)
+func (uart *UART) Receive(data byte)
 ```
 
 Receive handles adding data to the UART's data buffer.
 Usually called by the IRQ handler for a machine.
 
 
-### func (UART) Write
+### func (*UART) Write
 
 ```go
-func (uart UART) Write(data []byte) (n int, err error)
+func (uart *UART) Write(data []byte) (n int, err error)
 ```
 
-Write data to the UART.
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
 
 
-### func (UART) WriteByte
+### func (*UART) WriteByte
 
 ```go
-func (uart UART) WriteByte(c byte)
+func (uart *UART) WriteByte(c byte) error
 ```
 
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
 
 
 
@@ -647,9 +919,26 @@ type UARTConfig struct {
 	BaudRate	uint32
 	TX		Pin
 	RX		Pin
+	RTS		Pin
+	CTS		Pin
 }
 ```
 
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
 
 
 
diff --git a/content/docs/reference/microcontrollers/machine/itsybitsy-m0.md b/content/docs/reference/microcontrollers/machine/itsybitsy-m0.md
new file mode 100644
index 00000000..d97931ee
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/itsybitsy-m0.md
@@ -0,0 +1,1768 @@
+
+---
+title: itsybitsy-m0
+---
+
+
+## Constants
+
+```go
+const (
+	PA00	Pin	= 0	// peripherals: TCC2 channel 0, sercomI2CM1 SDA
+	PA01	Pin	= 1	// peripherals: TCC2 channel 1, sercomI2CM1 SCL
+	PA02	Pin	= 2
+	PA03	Pin	= 3
+	PA04	Pin	= 4	// peripherals: TCC0 channel 0
+	PA05	Pin	= 5	// peripherals: TCC0 channel 1
+	PA06	Pin	= 6	// peripherals: TCC1 channel 0
+	PA07	Pin	= 7	// peripherals: TCC1 channel 1
+	PA08	Pin	= 8	// peripherals: TCC0 channel 0, TCC1 channel 2, sercomI2CM0 SDA, sercomI2CM2 SDA
+	PA09	Pin	= 9	// peripherals: TCC0 channel 1, TCC1 channel 3, sercomI2CM0 SCL, sercomI2CM2 SCL
+	PA10	Pin	= 10	// peripherals: TCC1 channel 0, TCC0 channel 2
+	PA11	Pin	= 11	// peripherals: TCC1 channel 1, TCC0 channel 3
+	PA12	Pin	= 12	// peripherals: TCC2 channel 0, TCC0 channel 2, sercomI2CM2 SDA, sercomI2CM4 SDA
+	PA13	Pin	= 13	// peripherals: TCC2 channel 1, TCC0 channel 3, sercomI2CM2 SCL, sercomI2CM4 SCL
+	PA14	Pin	= 14	// peripherals: TCC0 channel 0
+	PA15	Pin	= 15	// peripherals: TCC0 channel 1
+	PA16	Pin	= 16	// peripherals: TCC2 channel 0, TCC0 channel 2, sercomI2CM1 SDA, sercomI2CM3 SDA
+	PA17	Pin	= 17	// peripherals: TCC2 channel 1, TCC0 channel 3, sercomI2CM1 SCL, sercomI2CM3 SCL
+	PA18	Pin	= 18	// peripherals: TCC0 channel 2
+	PA19	Pin	= 19	// peripherals: TCC0 channel 3
+	PA20	Pin	= 20	// peripherals: TCC0 channel 2
+	PA21	Pin	= 21	// peripherals: TCC0 channel 3
+	PA22	Pin	= 22	// peripherals: TCC0 channel 0, sercomI2CM3 SDA, sercomI2CM5 SDA
+	PA23	Pin	= 23	// peripherals: TCC0 channel 1, sercomI2CM3 SCL, sercomI2CM5 SCL
+	PA24	Pin	= 24	// peripherals: TCC1 channel 2
+	PA25	Pin	= 25	// peripherals: TCC1 channel 3
+	PA26	Pin	= 26
+	PA27	Pin	= 27
+	PA28	Pin	= 28
+	PA29	Pin	= 29
+	PA30	Pin	= 30	// peripherals: TCC1 channel 0
+	PA31	Pin	= 31	// peripherals: TCC1 channel 1
+	PB00	Pin	= 32
+	PB01	Pin	= 33
+	PB02	Pin	= 34	// peripherals: sercomI2CM5 SDA
+	PB03	Pin	= 35	// peripherals: sercomI2CM5 SCL
+	PB04	Pin	= 36
+	PB05	Pin	= 37
+	PB06	Pin	= 38
+	PB07	Pin	= 39
+	PB08	Pin	= 40	// peripherals: sercomI2CM4 SDA
+	PB09	Pin	= 41	// peripherals: sercomI2CM4 SCL
+	PB10	Pin	= 42	// peripherals: TCC0 channel 0
+	PB11	Pin	= 43	// peripherals: TCC0 channel 1
+	PB12	Pin	= 44	// peripherals: TCC0 channel 2, sercomI2CM4 SDA
+	PB13	Pin	= 45	// peripherals: TCC0 channel 3, sercomI2CM4 SCL
+	PB14	Pin	= 46
+	PB15	Pin	= 47
+	PB16	Pin	= 48	// peripherals: TCC0 channel 0, sercomI2CM5 SDA
+	PB17	Pin	= 49	// peripherals: TCC0 channel 1, sercomI2CM5 SCL
+	PB18	Pin	= 50
+	PB19	Pin	= 51
+	PB20	Pin	= 52
+	PB21	Pin	= 53
+	PB22	Pin	= 54
+	PB23	Pin	= 55
+	PB24	Pin	= 56
+	PB25	Pin	= 57
+	PB26	Pin	= 58
+	PB27	Pin	= 59
+	PB28	Pin	= 60
+	PB29	Pin	= 61
+	PB30	Pin	= 62	// peripherals: TCC0 channel 0, TCC1 channel 2, sercomI2CM5 SDA
+	PB31	Pin	= 63	// peripherals: TCC0 channel 1, TCC1 channel 3, sercomI2CM5 SCL
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	D0	= PA11	// UART0 RX
+	D1	= PA10	// UART0 TX
+	D2	= PA14
+	D3	= PA09	// PWM available
+	D4	= PA08	// PWM available
+	D5	= PA15	// PWM available
+	D6	= PA20	// PWM available
+	D7	= PA21	// PWM available
+	D8	= PA06	// PWM available
+	D9	= PA07	// PWM available
+	D10	= PA18	// can be used for PWM or UART1 TX
+	D11	= PA16	// can be used for PWM or UART1 RX
+	D12	= PA19	// PWM available
+	D13	= PA17	// PWM available
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A0	= PA02	// ADC/AIN[0]
+	A1	= PB08	// ADC/AIN[2]
+	A2	= PB09	// ADC/AIN[3]
+	A3	= PA04	// ADC/AIN[4]
+	A4	= PA05	// ADC/AIN[5]
+	A5	= PB02	// ADC/AIN[10]
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	LED = D13
+)
+```
+
+
+
+```go
+const (
+	USBCDC_DM_PIN	= PA24
+	USBCDC_DP_PIN	= PA25
+)
+```
+
+USBCDC pins
+
+
+```go
+const (
+	UART_TX_PIN	= D10
+	UART_RX_PIN	= D11
+)
+```
+
+UART1 pins
+
+
+```go
+const (
+	SDA_PIN	= PA22	// SDA: SERCOM3/PAD[0]
+	SCL_PIN	= PA23	// SCL: SERCOM3/PAD[1]
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= PB11	// SCK: SERCOM4/PAD[3]
+	SPI0_SDO_PIN	= PB10	// SDO: SERCOM4/PAD[2]
+	SPI0_SDI_PIN	= PA12	// SDI: SERCOM4/PAD[0]
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	SPI1_CS_PIN	= PA27
+	SPI1_SCK_PIN	= PB23
+	SPI1_SDO_PIN	= PB22
+	SPI1_SDI_PIN	= PB03
+)
+```
+
+"Internal" SPI pins; SPI flash is attached to these on ItsyBitsy M0
+
+
+```go
+const (
+	I2S_SCK_PIN	= PA10
+	I2S_SDO_PIN	= PA08
+	I2S_SDI_PIN	= NoPin
+	I2S_WS_PIN	= NoPin	// TODO: figure out what this is on ItsyBitsy M0.
+)
+```
+
+I2S pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const (
+	I2SModeSource	I2SMode	= iota
+	I2SModeReceiver
+	I2SModePDM
+	I2SModeSourceReceiver
+)
+```
+
+
+
+```go
+const (
+	I2StandardPhilips	I2SStandard	= iota
+	I2SStandardMSB
+	I2SStandardLSB
+)
+```
+
+
+
+```go
+const (
+	I2SClockSourceInternal	I2SClockSource	= iota
+	I2SClockSourceExternal
+)
+```
+
+
+
+```go
+const (
+	I2SDataFormatDefault	I2SDataFormat	= 0
+	I2SDataFormat8bit			= 8
+	I2SDataFormat16bit			= 16
+	I2SDataFormat24bit			= 24
+	I2SDataFormat32bit			= 32
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinAnalog	PinMode	= 1
+	PinSERCOM	PinMode	= 2
+	PinSERCOMAlt	PinMode	= 3
+	PinTimer	PinMode	= 4
+	PinTimerAlt	PinMode	= 5
+	PinCom		PinMode	= 6
+	//PinAC_CLK        PinMode = 7
+	PinDigital		PinMode	= 8
+	PinInput		PinMode	= 9
+	PinInputPullup		PinMode	= 10
+	PinOutput		PinMode	= 11
+	PinTCC			PinMode	= PinTimer
+	PinTCCAlt		PinMode	= PinTimerAlt
+	PinInputPulldown	PinMode	= 12
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
+	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
+	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (16s)
+	WatchdogMaxTimeout = (16384 * 1000) / 1024
+)
+```
+
+
+
+```go
+const (
+	// these are SAMD21 specific.
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Pos	= 0
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Mask	= 0x3FFF
+
+	usb_DEVICE_PCKSIZE_SIZE_Pos	= 28
+	usb_DEVICE_PCKSIZE_SIZE_Mask	= 0x7
+
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Pos	= 14
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Mask	= 0x3FFF
+
+	NumberOfUSBEndpoints	= 8
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	UART1 = &sercomUSART1
+)
+```
+
+UART1 on the ItsyBitsy M0.
+
+
+```go
+var (
+	I2C0 = sercomI2CM3
+)
+```
+
+I2C on the ItsyBitsy M0.
+
+
+```go
+var SPI0 = sercomSPIM4
+```
+
+SPI on the ItsyBitsy M0.
+
+
+```go
+var SPI1 = sercomSPIM5
+```
+
+"Internal" SPI on Sercom 5
+
+
+```go
+var (
+	DefaultUART = UART1
+)
+```
+
+
+
+```go
+var (
+	ErrInvalidSampleFrequency = errors.New("i2s: invalid sample frequency")
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var I2S0 = I2S{Bus: sam.I2S}
+```
+
+
+
+```go
+var (
+	TCC0	= (*TCC)(sam.TCC0)
+	TCC1	= (*TCC)(sam.TCC1)
+	TCC2	= (*TCC)(sam.TCC2)
+)
+```
+
+The SAM D21 has three TCC peripherals, which have PWM as one feature.
+
+
+```go
+var (
+	DAC0 = DAC{}
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the SAMD21.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+Return the current CPU frequency in hertz.
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) and 16 bytes (128 bits) are common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig)
+```
+
+Configure configures a ADC pin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type DAC
+
+```go
+type DAC struct {
+}
+```
+
+DAC on the SAMD21.
+
+
+
+### func (DAC) Configure
+
+```go
+func (dac DAC) Configure(config DACConfig)
+```
+
+Configure the DAC.
+output pin must already be configured.
+
+
+### func (DAC) Set
+
+```go
+func (dac DAC) Set(value uint16) error
+```
+
+Set writes a single 16-bit value to the DAC.
+Since the ATSAMD21 only has a 10-bit DAC, the passed-in value will be scaled down.
+
+
+
+
+## type DACConfig
+
+```go
+type DACConfig struct {
+}
+```
+
+DACConfig placeholder for future expansion.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*sam.SERCOM_I2CM_Type
+	SERCOM	uint8
+}
+```
+
+I2C on the SAMD21.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteByte
+
+```go
+func (i2c *I2C) WriteByte(data byte) error
+```
+
+WriteByte writes a single byte to the I2C bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type I2S
+
+```go
+type I2S struct {
+	Bus		*sam.I2S_Type
+	Frequency	uint32
+	DataFormat	I2SDataFormat
+}
+```
+
+I2S
+
+
+
+### func (*I2S) Configure
+
+```go
+func (i2s *I2S) Configure(config I2SConfig) error
+```
+
+Configure is used to configure the I2S interface. You must call this
+before you can use the I2S bus.
+
+
+### func (*I2S) Enable
+
+```go
+func (i2s *I2S) Enable(enabled bool)
+```
+
+Enabled is used to enable or disable the I2S bus.
+
+
+### func (*I2S) ReadMono
+
+```go
+func (i2s *I2S) ReadMono(p []uint16) (n int, err error)
+```
+
+Read mono data from the I2S bus into the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) ReadStereo
+
+```go
+func (i2s *I2S) ReadStereo(p []uint32) (n int, err error)
+```
+
+Read stereo data from the I2S bus into the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) SetSampleFrequency
+
+```go
+func (i2s *I2S) SetSampleFrequency(freq uint32) error
+```
+
+SetSampleFrequency is used to set the sample frequency for the I2S bus.
+
+
+### func (*I2S) WriteMono
+
+```go
+func (i2s *I2S) WriteMono(p []uint16) (n int, err error)
+```
+
+Write mono data to the I2S bus from the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) WriteStereo
+
+```go
+func (i2s *I2S) WriteStereo(p []uint32) (n int, err error)
+```
+
+Write stereo data to the I2S bus from the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+
+
+## type I2SClockSource
+
+```go
+type I2SClockSource uint8
+```
+
+
+
+
+
+
+## type I2SConfig
+
+```go
+type I2SConfig struct {
+	// clock
+	SCK	Pin
+	// word select
+	WS	Pin
+	// data out
+	SDO	Pin
+	// data in
+	SDI		Pin
+	Mode		I2SMode
+	Standard	I2SStandard
+	ClockSource	I2SClockSource
+	DataFormat	I2SDataFormat
+	AudioFrequency	uint32
+	MainClockOutput	bool
+	Stereo		bool
+}
+```
+
+All fields are optional and may not be required or used on a particular platform.
+
+
+
+
+
+## type I2SDataFormat
+
+```go
+type I2SDataFormat uint8
+```
+
+
+
+
+
+
+## type I2SMode
+
+```go
+type I2SMode uint8
+```
+
+
+
+
+
+
+## type I2SStandard
+
+```go
+type I2SStandard uint8
+```
+
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when configured as an input or as
+an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*sam.SERCOM_SPI_Type
+	SERCOM	uint8
+}
+```
+
+SPI
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type TCC
+
+```go
+type TCC sam.TCC_Type
+```
+
+TCC is one timer/counter peripheral, which consists of a counter and multiple
+output channels (that can be connected to actual pins). You can set the
+frequency using SetPeriod, but only for all the channels in this TCC
+peripheral at once.
+
+
+
+### func (*TCC) Channel
+
+```go
+func (tcc *TCC) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin. Note that one channel may be
+shared between multiple pins, and so will have the same duty cycle. If this
+is not desirable, look for a different TCC peripheral or consider using a
+different pin.
+
+
+### func (*TCC) Configure
+
+```go
+func (tcc *TCC) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this TCC.
+
+
+### func (*TCC) Counter
+
+```go
+func (tcc *TCC) Counter() uint32
+```
+
+Counter returns the current counter value of the timer in this TCC
+peripheral. It may be useful for debugging.
+
+
+### func (*TCC) Set
+
+```go
+func (tcc *TCC) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle, in other words the fraction of time the channel output is high (or low
+when inverted). For example, to set it to a 25% duty cycle, use:
+
+	tcc.Set(channel, tcc.Top() / 4)
+
+tcc.Set(channel, 0) will set the output to low and tcc.Set(channel,
+tcc.Top()) will set the output to high, assuming the output isn't inverted.
+
+
+### func (*TCC) SetInverting
+
+```go
+func (tcc *TCC) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TCC) SetPeriod
+
+```go
+func (tcc *TCC) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this TCC peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the TCC peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TCC) Top
+
+```go
+func (tcc *TCC) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to Set
+(see Set documentation for more information).
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*sam.SERCOM_USART_Type
+	SERCOM		uint8
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the SAMD21.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/itsybitsy-m4.md b/content/docs/reference/microcontrollers/machine/itsybitsy-m4.md
new file mode 100644
index 00000000..ac114d41
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/itsybitsy-m4.md
@@ -0,0 +1,1666 @@
+
+---
+title: itsybitsy-m4
+---
+
+
+## Constants
+
+```go
+const (
+	D0	= PA16	// UART0 RX/PWM available
+	D1	= PA17	// UART0 TX/PWM available
+	D2	= PA07
+	D3	= PB22
+	D4	= PA14	// PWM available
+	D5	= PA15	// PWM available
+	D6	= PB02	// dotStar clock
+	D7	= PA18	// PWM available
+	D8	= PB03	// dotStar data
+	D9	= PA19	// PWM available
+	D10	= PA20	// can be used for PWM or UART1 TX
+	D11	= PA21	// can be used for PWM or UART1 RX
+	D12	= PA23	// PWM available
+	D13	= PA22	// PWM available
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A0	= PA02	// ADC/AIN[0]
+	A1	= PA05	// ADC/AIN[2]
+	A2	= PB08	// ADC/AIN[3]
+	A3	= PB09	// ADC/AIN[4]
+	A4	= PA04	// ADC/AIN[5]
+	A5	= PA06	// ADC/AIN[10]
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	LED = D13
+)
+```
+
+
+
+```go
+const (
+	USBCDC_DM_PIN	= PA24
+	USBCDC_DP_PIN	= PA25
+)
+```
+
+USBCDC pins
+
+
+```go
+const (
+	UART_TX_PIN	= D1
+	UART_RX_PIN	= D0
+)
+```
+
+UART1 pins
+
+
+```go
+const (
+	UART2_TX_PIN	= A4
+	UART2_RX_PIN	= D2
+)
+```
+
+
+
+```go
+const (
+	SDA_PIN	= PA12	// SDA: SERCOM2/PAD[0]
+	SCL_PIN	= PA13	// SCL: SERCOM2/PAD[1]
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= PA01	// SCK: SERCOM1/PAD[1]
+	SPI0_SDO_PIN	= PA00	// SDO: SERCOM1/PAD[0]
+	SPI0_SDI_PIN	= PB23	// SDI: SERCOM1/PAD[3]
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinAnalog		PinMode	= 1
+	PinSERCOM		PinMode	= 2
+	PinSERCOMAlt		PinMode	= 3
+	PinTimer		PinMode	= 4
+	PinTimerAlt		PinMode	= 5
+	PinTCCPDEC		PinMode	= 6
+	PinCom			PinMode	= 7
+	PinSDHC			PinMode	= 8
+	PinI2S			PinMode	= 9
+	PinPCC			PinMode	= 10
+	PinGMAC			PinMode	= 11
+	PinACCLK		PinMode	= 12
+	PinCCL			PinMode	= 13
+	PinDigital		PinMode	= 14
+	PinInput		PinMode	= 15
+	PinInputPullup		PinMode	= 16
+	PinOutput		PinMode	= 17
+	PinTCCE			PinMode	= PinTimer
+	PinTCCF			PinMode	= PinTimerAlt
+	PinTCCG			PinMode	= PinTCCPDEC
+	PinInputPulldown	PinMode	= 18
+	PinCAN			PinMode	= 19
+	PinCAN0			PinMode	= PinSDHC
+	PinCAN1			PinMode	= PinCom
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
+	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
+	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	PA00	Pin	= 0
+	PA01	Pin	= 1
+	PA02	Pin	= 2
+	PA03	Pin	= 3
+	PA04	Pin	= 4
+	PA05	Pin	= 5
+	PA06	Pin	= 6
+	PA07	Pin	= 7
+	PA08	Pin	= 8	// peripherals: TCC0 channel 0, TCC1 channel 4, sercomI2CM0 SDA, sercomI2CM2 SDA
+	PA09	Pin	= 9	// peripherals: TCC0 channel 1, TCC1 channel 5, sercomI2CM0 SCL, sercomI2CM2 SCL
+	PA10	Pin	= 10	// peripherals: TCC0 channel 2, TCC1 channel 6
+	PA11	Pin	= 11	// peripherals: TCC0 channel 3, TCC1 channel 7
+	PA12	Pin	= 12	// peripherals: TCC0 channel 6, TCC1 channel 2, sercomI2CM2 SDA, sercomI2CM4 SDA
+	PA13	Pin	= 13	// peripherals: TCC0 channel 7, TCC1 channel 3, sercomI2CM2 SCL, sercomI2CM4 SCL
+	PA14	Pin	= 14	// peripherals: TCC2 channel 0, TCC1 channel 2
+	PA15	Pin	= 15	// peripherals: TCC2 channel 1, TCC1 channel 3
+	PA16	Pin	= 16	// peripherals: TCC1 channel 0, TCC0 channel 4, sercomI2CM1 SDA, sercomI2CM3 SDA
+	PA17	Pin	= 17	// peripherals: TCC1 channel 1, TCC0 channel 5, sercomI2CM1 SCL, sercomI2CM3 SCL
+	PA18	Pin	= 18	// peripherals: TCC1 channel 2, TCC0 channel 6
+	PA19	Pin	= 19	// peripherals: TCC1 channel 3, TCC0 channel 7
+	PA20	Pin	= 20	// peripherals: TCC1 channel 4, TCC0 channel 0
+	PA21	Pin	= 21	// peripherals: TCC1 channel 5, TCC0 channel 1
+	PA22	Pin	= 22	// peripherals: TCC1 channel 6, TCC0 channel 2, sercomI2CM3 SDA, sercomI2CM5 SDA
+	PA23	Pin	= 23	// peripherals: TCC1 channel 7, TCC0 channel 3, sercomI2CM3 SCL, sercomI2CM5 SCL
+	PA24	Pin	= 24	// peripherals: TCC2 channel 2
+	PA25	Pin	= 25	// peripherals: TCC2 channel 3
+	PA26	Pin	= 26
+	PA27	Pin	= 27
+	PA28	Pin	= 28
+	PA29	Pin	= 29
+	PA30	Pin	= 30	// peripherals: TCC2 channel 0
+	PA31	Pin	= 31	// peripherals: TCC2 channel 1
+	PB00	Pin	= 32
+	PB01	Pin	= 33
+	PB02	Pin	= 34	// peripherals: TCC2 channel 2
+	PB03	Pin	= 35	// peripherals: TCC2 channel 3
+	PB04	Pin	= 36
+	PB05	Pin	= 37
+	PB06	Pin	= 38
+	PB07	Pin	= 39
+	PB08	Pin	= 40
+	PB09	Pin	= 41
+	PB10	Pin	= 42	// peripherals: TCC0 channel 4, TCC1 channel 0
+	PB11	Pin	= 43	// peripherals: TCC0 channel 5, TCC1 channel 1
+	PB12	Pin	= 44	// peripherals: TCC3 channel 0, TCC0 channel 0
+	PB13	Pin	= 45	// peripherals: TCC3 channel 1, TCC0 channel 1
+	PB14	Pin	= 46	// peripherals: TCC4 channel 0, TCC0 channel 2
+	PB15	Pin	= 47	// peripherals: TCC4 channel 1, TCC0 channel 3
+	PB16	Pin	= 48	// peripherals: TCC3 channel 0, TCC0 channel 4
+	PB17	Pin	= 49	// peripherals: TCC3 channel 1, TCC0 channel 5
+	PB18	Pin	= 50	// peripherals: TCC1 channel 0
+	PB19	Pin	= 51	// peripherals: TCC1 channel 1
+	PB20	Pin	= 52	// peripherals: TCC1 channel 2
+	PB21	Pin	= 53	// peripherals: TCC1 channel 3
+	PB22	Pin	= 54
+	PB23	Pin	= 55
+	PB24	Pin	= 56
+	PB25	Pin	= 57
+	PB26	Pin	= 58	// peripherals: TCC1 channel 2
+	PB27	Pin	= 59	// peripherals: TCC1 channel 3
+	PB28	Pin	= 60	// peripherals: TCC1 channel 4
+	PB29	Pin	= 61	// peripherals: TCC1 channel 5
+	PB30	Pin	= 62	// peripherals: TCC4 channel 0, TCC0 channel 6
+	PB31	Pin	= 63	// peripherals: TCC4 channel 1, TCC0 channel 7
+	PC00	Pin	= 64
+	PC01	Pin	= 65
+	PC02	Pin	= 66
+	PC03	Pin	= 67
+	PC04	Pin	= 68	// peripherals: TCC0 channel 0
+	PC05	Pin	= 69	// peripherals: TCC0 channel 1
+	PC06	Pin	= 70
+	PC07	Pin	= 71
+	PC08	Pin	= 72
+	PC09	Pin	= 73
+	PC10	Pin	= 74	// peripherals: TCC0 channel 0, TCC1 channel 4
+	PC11	Pin	= 75	// peripherals: TCC0 channel 1, TCC1 channel 5
+	PC12	Pin	= 76	// peripherals: TCC0 channel 2, TCC1 channel 6
+	PC13	Pin	= 77	// peripherals: TCC0 channel 3, TCC1 channel 7
+	PC14	Pin	= 78	// peripherals: TCC0 channel 4, TCC1 channel 0
+	PC15	Pin	= 79	// peripherals: TCC0 channel 5, TCC1 channel 1
+	PC16	Pin	= 80	// peripherals: TCC0 channel 0
+	PC17	Pin	= 81	// peripherals: TCC0 channel 1
+	PC18	Pin	= 82	// peripherals: TCC0 channel 2
+	PC19	Pin	= 83	// peripherals: TCC0 channel 3
+	PC20	Pin	= 84	// peripherals: TCC0 channel 4
+	PC21	Pin	= 85	// peripherals: TCC0 channel 5
+	PC22	Pin	= 86	// peripherals: TCC0 channel 6
+	PC23	Pin	= 87	// peripherals: TCC0 channel 7
+	PC24	Pin	= 88
+	PC25	Pin	= 89
+	PC26	Pin	= 90
+	PC27	Pin	= 91
+	PC28	Pin	= 92
+	PC29	Pin	= 93
+	PC30	Pin	= 94
+	PC31	Pin	= 95
+	PD00	Pin	= 96
+	PD01	Pin	= 97
+	PD02	Pin	= 98
+	PD03	Pin	= 99
+	PD04	Pin	= 100
+	PD05	Pin	= 101
+	PD06	Pin	= 102
+	PD07	Pin	= 103
+	PD08	Pin	= 104	// peripherals: TCC0 channel 1, sercomI2CM6 SDA, sercomI2CM7 SDA
+	PD09	Pin	= 105	// peripherals: TCC0 channel 2, sercomI2CM6 SCL, sercomI2CM7 SCL
+	PD10	Pin	= 106	// peripherals: TCC0 channel 3
+	PD11	Pin	= 107	// peripherals: TCC0 channel 4
+	PD12	Pin	= 108	// peripherals: TCC0 channel 5
+	PD13	Pin	= 109	// peripherals: TCC0 channel 6
+	PD14	Pin	= 110
+	PD15	Pin	= 111
+	PD16	Pin	= 112
+	PD17	Pin	= 113
+	PD18	Pin	= 114
+	PD19	Pin	= 115
+	PD20	Pin	= 116	// peripherals: TCC1 channel 0
+	PD21	Pin	= 117	// peripherals: TCC1 channel 1
+	PD22	Pin	= 118
+	PD23	Pin	= 119
+	PD24	Pin	= 120
+	PD25	Pin	= 121
+	PD26	Pin	= 122
+	PD27	Pin	= 123
+	PD28	Pin	= 124
+	PD29	Pin	= 125
+	PD30	Pin	= 126
+	PD31	Pin	= 127
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	// SERCOM_FREQ_REF is always reference frequency on SAMD51 regardless of CPU speed.
+	SERCOM_FREQ_REF		= 48000000
+	SERCOM_FREQ_REF_GCLK0	= 120000000
+
+	// Default rise time in nanoseconds, based on 4.7K ohm pull up resistors
+	riseTimeNanoseconds	= 125
+
+	// wire bus states
+	wireUnknownState	= 0
+	wireIdleState		= 1
+	wireOwnerState		= 2
+	wireBusyState		= 3
+
+	// wire commands
+	wireCmdNoAction		= 0
+	wireCmdRepeatStart	= 1
+	wireCmdRead		= 2
+	wireCmdStop		= 3
+)
+```
+
+
+
+```go
+const (
+	QSPI_SCK	= PB10
+	QSPI_CS		= PB11
+	QSPI_DATA0	= PA08
+	QSPI_DATA1	= PA09
+	QSPI_DATA2	= PA10
+	QSPI_DATA3	= PA11
+)
+```
+
+The QSPI peripheral on ATSAMD51 is only available on the following pins
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (16s)
+	WatchdogMaxTimeout = (16384 * 1000) / 1024	// CYC16384/1024kHz
+)
+```
+
+
+
+```go
+const (
+	// these are SAMD51 specific.
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Pos	= 0
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Mask	= 0x3FFF
+
+	usb_DEVICE_PCKSIZE_SIZE_Pos	= 28
+	usb_DEVICE_PCKSIZE_SIZE_Mask	= 0x7
+
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Pos	= 14
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Mask	= 0x3FFF
+
+	NumberOfUSBEndpoints	= 8
+)
+```
+
+
+
+```go
+const HSRAM_SIZE = 0x00030000
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	UART1	= &sercomUSART3
+	UART2	= &sercomUSART0
+
+	DefaultUART	= UART1
+)
+```
+
+
+
+```go
+var (
+	I2C0 = sercomI2CM2
+)
+```
+
+I2C on the ItsyBitsy M4.
+
+
+```go
+var SPI0 = sercomSPIM1
+```
+
+SPI on the ItsyBitsy M4.
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	DAC0	= DAC{Channel: 0}
+	DAC1	= DAC{Channel: 1}
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the SAMD51.
+
+
+```go
+var (
+	TCC0	= (*TCC)(sam.TCC0)
+	TCC1	= (*TCC)(sam.TCC1)
+	TCC2	= (*TCC)(sam.TCC2)
+)
+```
+
+This chip has three TCC peripherals, which have PWM as one feature.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) and 16 bytes (128 bits) are common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of cryptographically secure random data
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig)
+```
+
+Configure configures a ADCPin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type DAC
+
+```go
+type DAC struct {
+	Channel uint8
+}
+```
+
+DAC on the SAMD51.
+
+
+
+### func (DAC) Configure
+
+```go
+func (dac DAC) Configure(config DACConfig)
+```
+
+Configure the DAC.
+output pin must already be configured.
+
+
+### func (DAC) Set
+
+```go
+func (dac DAC) Set(value uint16) error
+```
+
+Set writes a single 16-bit value to the DAC.
+Since the ATSAMD51 only has a 12-bit DAC, the passed-in value will be scaled down.
+
+
+
+
+## type DACConfig
+
+```go
+type DACConfig struct {
+}
+```
+
+DACConfig placeholder for future expansion.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*sam.SERCOM_I2CM_Type
+	SERCOM	uint8
+}
+```
+
+I2C on the SAMD51.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteByte
+
+```go
+func (i2c *I2C) WriteByte(data byte) error
+```
+
+WriteByte writes a single byte to the I2C bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when configured as an input or as
+an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+### func (Pin) Toggle
+
+```go
+func (p Pin) Toggle()
+```
+
+Toggle switches an output pin from low to high or from high to low.
+Warning: only use this on an output pin!
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*sam.SERCOM_SPIM_Type
+	SERCOM	uint8
+}
+```
+
+SPI
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type TCC
+
+```go
+type TCC sam.TCC_Type
+```
+
+TCC is one timer peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this timer peripheral at
+once.
+
+
+
+### func (*TCC) Channel
+
+```go
+func (tcc *TCC) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin. Note that one channel may be
+shared between multiple pins, and so will have the same duty cycle. If this
+is not desirable, look for a different TCC or consider using a different pin.
+
+
+### func (*TCC) Configure
+
+```go
+func (tcc *TCC) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this TCC.
+
+
+### func (*TCC) Counter
+
+```go
+func (tcc *TCC) Counter() uint32
+```
+
+Counter returns the current counter value of the timer in this TCC
+peripheral. It may be useful for debugging.
+
+
+### func (*TCC) Set
+
+```go
+func (tcc *TCC) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle, in other words the fraction of time the channel output is high (or low
+when inverted). For example, to set it to a 25% duty cycle, use:
+
+	tcc.Set(channel, tcc.Top() / 4)
+
+tcc.Set(channel, 0) will set the output to low and tcc.Set(channel,
+tcc.Top()) will set the output to high, assuming the output isn't inverted.
+
+
+### func (*TCC) SetInverting
+
+```go
+func (tcc *TCC) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TCC) SetPeriod
+
+```go
+func (tcc *TCC) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this TCC peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the TCC peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TCC) Top
+
+```go
+func (tcc *TCC) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+tcc.Set (see tcc.Set for more information).
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*sam.SERCOM_USART_INT_Type
+	SERCOM		uint8
+	Interrupt	interrupt.Interrupt	// RXC interrupt
+}
+```
+
+UART on the SAMD51.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/itsybitsy-nrf52840.md b/content/docs/reference/microcontrollers/machine/itsybitsy-nrf52840.md
new file mode 100644
index 00000000..d8102c38
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/itsybitsy-nrf52840.md
@@ -0,0 +1,1557 @@
+
+---
+title: itsybitsy-nrf52840
+---
+
+
+## Constants
+
+```go
+const HasLowFrequencyCrystal = true
+```
+
+
+
+```go
+const (
+	D0	= P0_25	// UART TX
+	D1	= P0_24	// UART RX
+	D2	= P1_02
+	D3	= P0_06	// LED1
+	D4	= P0_29	// Button
+	D5	= P0_27
+	D6	= P1_09	// DotStar Clock
+	D7	= P1_08
+	D8	= P0_08	// DotStar Data
+	D9	= P0_07
+	D10	= P0_05
+	D11	= P0_26
+	D12	= P0_11
+	D13	= P0_12
+	D14	= P0_04	// A0
+	D15	= P0_30	// A1
+	D16	= P0_28	// A2
+	D17	= P0_31	// A3
+	D18	= P0_02	// A4
+	D19	= P0_03	// A5
+	D20	= P0_05	// A6
+	D21	= P0_16	// I2C SDA
+	D22	= P0_14	// I2C SCL
+	D23	= P0_20	// SPI SDI
+	D24	= P0_15	// SPI SDO
+	D25	= P0_13	// SPI SCK
+	D26	= P0_19	// QSPI SCK
+	D27	= P0_23	// QSPI CS
+	D28	= P0_21	// QSPI Data 0
+	D29	= P0_22	// QSPI Data 1
+	D30	= P1_00	// QSPI Data 2
+	D31	= P0_17	// QSPI Data 3
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A0	= D14
+	A1	= D15
+	A2	= D16
+	A3	= D17
+	A4	= D18
+	A5	= D19
+	A6	= D20
+)
+```
+
+Analog Pins
+
+
+```go
+const (
+	LED	= D3
+	LED1	= LED
+	BUTTON	= D4
+
+	QSPI_SCK	= D26
+	QSPI_CS		= D27
+	QSPI_DATA0	= D28
+	QSPI_DATA1	= D29
+	QSPI_DATA2	= D30
+	QSPI_DATA3	= D31
+)
+```
+
+
+
+```go
+const (
+	UART_RX_PIN	= D0
+	UART_TX_PIN	= D1
+)
+```
+
+UART0 pins (logical UART1)
+
+
+```go
+const (
+	SDA_PIN	= D21	// I2C0 external
+	SCL_PIN	= D22	// I2C0 external
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= D25
+	SPI0_SDO_PIN	= D24
+	SPI0_SDI_PIN	= D23
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	P0_00	Pin	= 0
+	P0_01	Pin	= 1
+	P0_02	Pin	= 2
+	P0_03	Pin	= 3
+	P0_04	Pin	= 4
+	P0_05	Pin	= 5
+	P0_06	Pin	= 6
+	P0_07	Pin	= 7
+	P0_08	Pin	= 8
+	P0_09	Pin	= 9
+	P0_10	Pin	= 10
+	P0_11	Pin	= 11
+	P0_12	Pin	= 12
+	P0_13	Pin	= 13
+	P0_14	Pin	= 14
+	P0_15	Pin	= 15
+	P0_16	Pin	= 16
+	P0_17	Pin	= 17
+	P0_18	Pin	= 18
+	P0_19	Pin	= 19
+	P0_20	Pin	= 20
+	P0_21	Pin	= 21
+	P0_22	Pin	= 22
+	P0_23	Pin	= 23
+	P0_24	Pin	= 24
+	P0_25	Pin	= 25
+	P0_26	Pin	= 26
+	P0_27	Pin	= 27
+	P0_28	Pin	= 28
+	P0_29	Pin	= 29
+	P0_30	Pin	= 30
+	P0_31	Pin	= 31
+	P1_00	Pin	= 32
+	P1_01	Pin	= 33
+	P1_02	Pin	= 34
+	P1_03	Pin	= 35
+	P1_04	Pin	= 36
+	P1_05	Pin	= 37
+	P1_06	Pin	= 38
+	P1_07	Pin	= 39
+	P1_08	Pin	= 40
+	P1_09	Pin	= 41
+	P1_10	Pin	= 42
+	P1_11	Pin	= 43
+	P1_12	Pin	= 44
+	P1_13	Pin	= 45
+	P1_14	Pin	= 46
+	P1_15	Pin	= 47
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
+	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
+	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 36h)
+	WatchdogMaxTimeout = (0xffffffff * 1000) / 32768
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	DefaultUART = UART0
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	// UART0 is the hardware UART on the NRF SoC.
+	_UART0	= UART{Buffer: NewRingBuffer()}
+	UART0	= &_UART0
+)
+```
+
+UART
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	PWM0	= &PWM{PWM: nrf.PWM0}
+	PWM1	= &PWM{PWM: nrf.PWM1}
+	PWM2	= &PWM{PWM: nrf.PWM2}
+	PWM3	= &PWM{PWM: nrf.PWM3}
+)
+```
+
+PWM
+
+
+```go
+var (
+	I2C0	= &I2C{Bus: nrf.TWIM0, BusT: nrf.TWIS0}
+	I2C1	= &I2C{Bus: nrf.TWIM1, BusT: nrf.TWIS1}
+)
+```
+
+There are 2 I2C interfaces on the NRF.
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	SPI0	= &SPI{Bus: nrf.SPIM0, buf: new([1]byte)}
+	SPI1	= &SPI{Bus: nrf.SPIM1, buf: new([1]byte)}
+	SPI2	= &SPI{Bus: nrf.SPIM2, buf: new([1]byte)}
+)
+```
+
+There are 3 SPI interfaces on the NRF528xx.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader resets the chip into the UF2 bootloader. After reset, it
+can be flashed via nrfutil or by copying a UF2 file to the mass storage device
+
+
+### func EnterOTABootloader
+
+```go
+func EnterOTABootloader()
+```
+
+EnterOTABootloader resets the chip into the bootloader so that it can be
+flashed via an OTA update
+
+
+### func EnterSerialBootloader
+
+```go
+func EnterSerialBootloader()
+```
+
+EnterSerialBootloader resets the chip into the serial bootloader. After
+reset, it can be flashed using serial/nrfutil.
+
+
+### func EnterUF2Bootloader
+
+```go
+func EnterUF2Bootloader()
+```
+
+EnterUF2Bootloader resets the chip into the UF2 bootloader. After reset, it
+can be flashed via nrfutil or by copying a UF2 file to the mass storage device
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (ret uint32, err error)
+```
+
+GetRNG returns 32 bits of non-deterministic random data based on internal thermal noise.
+According to Nordic's documentation, the random output is suitable for cryptographic purposes.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() int32
+```
+
+ReadTemperature reads the silicon die temperature of the chip. The return
+value is in milli-celsius.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USBHID (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (*ADC) Configure
+
+```go
+func (a *ADC) Configure(config ADCConfig)
+```
+
+Configure configures an ADC pin to be able to read analog data.
+Reference voltage can be 150, 300, 600, 1200, 1800, 2400, 3000(default), 3600 mV
+Resolution can be 8, 10, 12(default), 14 bits
+SampleTime will be ceiled to 3(default), 5, 10, 15, 20 or 40(max) µS respectively
+Samples can be 1(default), 2, 4, 8, 16, 32, 64, 128, 256 samples
+
+
+### func (*ADC) Get
+
+```go
+func (a *ADC) Get() uint16
+```
+
+Get returns the current value of an ADC pin in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*nrf.TWIM_Type	// Called Bus to align with Bus field in nrf51
+	BusT	*nrf.TWIS_Type
+	mode	I2CMode
+}
+```
+
+I2C on the NRF528xx.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint8) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+Reply supplies the response data the controller.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) (err error)
+```
+
+Tx does a single I2C transaction at the specified address (when in controller mode).
+
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+WaitForEvent blocks the current go-routine until an I2C event is received (when in Target mode).
+
+The passed buffer will be populated for receive events, with the number of bytes
+received returned in count.  For other event types, buf is not modified and a count
+of zero is returned.
+
+For request events, the caller MUST call `Reply` to avoid hanging the i2c bus indefinitely.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDM
+
+```go
+type PDM struct {
+	device		*nrf.PDM_Type
+	defaultBuffer	int16
+}
+```
+
+PDM represents a PDM device
+
+
+
+### func (*PDM) Configure
+
+```go
+func (pdm *PDM) Configure(config PDMConfig) error
+```
+
+Configure is intended to set up the PDM interface prior to use.
+
+
+### func (*PDM) Read
+
+```go
+func (pdm *PDM) Read(buf []int16) (uint32, error)
+```
+
+Read stores a set of samples in the given target buffer.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWM
+
+```go
+type PWM struct {
+	PWM	*nrf.PWM_Type
+
+	channelValues	[4]volatile.Register16
+}
+```
+
+PWM is one PWM peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this PWM peripheral at
+once.
+
+
+
+### func (*PWM) Channel
+
+```go
+func (pwm *PWM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*PWM) Configure
+
+```go
+func (pwm *PWM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+On the nRF52 series, the maximum period is around 0.26s.
+
+
+### func (*PWM) Set
+
+```go
+func (pwm *PWM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	ch.Set(ch.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*PWM) SetInverting
+
+```go
+func (pwm *PWM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*PWM) SetPeriod
+
+```go
+func (pwm *PWM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*PWM) Top
+
+```go
+func (pwm *PWM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*nrf.SPIM_Type
+	buf	*[1]byte	// 1-byte buffer for the Transfer method
+}
+```
+
+SPI on the NRF.
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to set up the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous
+write/read interface, there must always be the same number of bytes written
+as bytes read. Therefore, if the number of bytes don't match it will be
+padded until they fit: if len(w) > len(r) the extra bytes received will be
+dropped and if len(w) < len(r) extra 0 bytes will be sent.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer *RingBuffer
+}
+```
+
+UART on the NRF.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/lgt92.md b/content/docs/reference/microcontrollers/machine/lgt92.md
new file mode 100644
index 00000000..4c431a5b
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/lgt92.md
@@ -0,0 +1,1555 @@
+
+---
+title: lgt92
+---
+
+
+## Constants
+
+```go
+const (
+	LED1	= PA12
+	LED2	= PA8
+	LED3	= PA11
+
+	LED_RED		= LED1
+	LED_BLUE	= LED2
+	LED_GREEN	= LED3
+
+	// Default led
+	LED	= LED1
+
+	BUTTON	= PB14
+
+	// LG GPS module
+	GPS_STANDBY_PIN	= PB3
+	GPS_RESET_PIN	= PB4
+	GPS_POWER_PIN	= PB5
+
+	MEMS_ACCEL_CS	= PE3
+	MEMS_ACCEL_INT1	= PE0
+	MEMS_ACCEL_INT2	= PE1
+
+	// SPI
+	SPI1_SCK_PIN	= PA5
+	SPI1_SDI_PIN	= PA6
+	SPI1_SDO_PIN	= PA7
+	SPI0_SCK_PIN	= SPI1_SCK_PIN
+	SPI0_SDI_PIN	= SPI1_SDI_PIN
+	SPI0_SDO_PIN	= SPI1_SDO_PIN
+
+	// LORA RFM95 Radio
+	RFM95_DIO0_PIN	= PC13
+
+	// TinyGo UART is MCU LPUSART1
+	UART_RX_PIN	= PA13
+	UART_TX_PIN	= PA14
+
+	// TinyGo UART1 is MCU USART1
+	UART1_RX_PIN	= PB6
+	UART1_TX_PIN	= PB7
+
+	// MPU9250 Nine-Axis (Gyro + Accelerometer + Compass)
+	I2C0_SCL_PIN	= PA9
+	I2C0_SDA_PIN	= PA10
+)
+```
+
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinRising	PinChange	= 1 << iota
+	PinFalling
+	PinToggle	= PinRising | PinFalling
+)
+```
+
+
+
+```go
+const (
+	MAX_NBYTE_SIZE	= 255
+
+	// 100ms delay = 100e6ns / 16ns
+	// In runtime_stm32_timers.go, tick is fixed at 16ns per tick
+	TIMEOUT_TICKS	= 100e6 / 16
+
+	I2C_NO_STARTSTOP		= 0x0
+	I2C_GENERATE_START_WRITE	= 0x80000000 | stm32.I2C_CR2_START
+	I2C_GENERATE_START_READ		= 0x80000000 | stm32.I2C_CR2_START | stm32.I2C_CR2_RD_WRN
+	I2C_GENERATE_STOP		= 0x80000000 | stm32.I2C_CR2_STOP
+)
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (32.768s)
+	//
+	// Timeout is based on 12-bit counter with /256 divider on
+	// 32.768kHz clock.  See 21.3.3 of RM0090 for table.
+	WatchdogMaxTimeout = ((0xfff + 1) * 256 * 1024) / 32768
+)
+```
+
+
+
+```go
+const (
+	// Mode Flag
+	PinOutput		PinMode	= 0
+	PinInput		PinMode	= PinInputFloating
+	PinInputFloating	PinMode	= 1
+	PinInputPulldown	PinMode	= 2
+	PinInputPullup		PinMode	= 3
+
+	// for UART
+	PinModeUARTTX	PinMode	= 4
+	PinModeUARTRX	PinMode	= 5
+
+	// for I2C
+	PinModeI2CSCL	PinMode	= 6
+	PinModeI2CSDA	PinMode	= 7
+
+	// for SPI
+	PinModeSPICLK	PinMode	= 8
+	PinModeSPISDO	PinMode	= 9
+	PinModeSPISDI	PinMode	= 10
+
+	// for analog/ADC
+	PinInputAnalog	PinMode	= 11
+
+	// for PWM
+	PinModePWMOutput	PinMode	= 12
+)
+```
+
+
+
+```go
+const RNG_MAX_READ_RETRIES = 1000
+```
+
+
+
+```go
+const PWM_MODE1 = 0x6
+```
+
+
+
+```go
+const APB1_TIM_FREQ = 32e6	// 32MHz
+
+```
+
+Internal use: configured speed of the APB1 and APB2 timers, this should be kept
+in sync with any changes to runtime package which configures the oscillators
+and clock frequencies
+
+
+```go
+const APB2_TIM_FREQ = 32e6	// 32MHz
+
+```
+
+
+
+```go
+const (
+	PA0	= portA + 0
+	PA1	= portA + 1
+	PA2	= portA + 2
+	PA3	= portA + 3
+	PA4	= portA + 4
+	PA5	= portA + 5
+	PA6	= portA + 6
+	PA7	= portA + 7
+	PA8	= portA + 8
+	PA9	= portA + 9
+	PA10	= portA + 10
+	PA11	= portA + 11
+	PA12	= portA + 12
+	PA13	= portA + 13
+	PA14	= portA + 14
+	PA15	= portA + 15
+
+	PB0	= portB + 0
+	PB1	= portB + 1
+	PB2	= portB + 2
+	PB3	= portB + 3
+	PB4	= portB + 4
+	PB5	= portB + 5
+	PB6	= portB + 6
+	PB7	= portB + 7
+	PB8	= portB + 8
+	PB9	= portB + 9
+	PB10	= portB + 10
+	PB11	= portB + 11
+	PB12	= portB + 12
+	PB13	= portB + 13
+	PB14	= portB + 14
+	PB15	= portB + 15
+
+	PC0	= portC + 0
+	PC1	= portC + 1
+	PC2	= portC + 2
+	PC3	= portC + 3
+	PC4	= portC + 4
+	PC5	= portC + 5
+	PC6	= portC + 6
+	PC7	= portC + 7
+	PC8	= portC + 8
+	PC9	= portC + 9
+	PC10	= portC + 10
+	PC11	= portC + 11
+	PC12	= portC + 12
+	PC13	= portC + 13
+	PC14	= portC + 14
+	PC15	= portC + 15
+
+	PD0	= portD + 0
+	PD1	= portD + 1
+	PD2	= portD + 2
+	PD3	= portD + 3
+	PD4	= portD + 4
+	PD5	= portD + 5
+	PD6	= portD + 6
+	PD7	= portD + 7
+	PD8	= portD + 8
+	PD9	= portD + 9
+	PD10	= portD + 10
+	PD11	= portD + 11
+	PD12	= portD + 12
+	PD13	= portD + 13
+	PD14	= portD + 14
+	PD15	= portD + 15
+
+	PE0	= portE + 0
+	PE1	= portE + 1
+	PE2	= portE + 2
+	PE3	= portE + 3
+	PE4	= portE + 4
+	PE5	= portE + 5
+	PE6	= portE + 6
+	PE7	= portE + 7
+	PE8	= portE + 8
+	PE9	= portE + 9
+	PE10	= portE + 10
+	PE11	= portE + 11
+	PE12	= portE + 12
+	PE13	= portE + 13
+	PE14	= portE + 14
+	PE15	= portE + 15
+
+	PH0	= portH + 0
+	PH1	= portH + 1
+)
+```
+
+
+
+```go
+const (
+	AF0_SYSTEM_SPI1_2_I2S2_USART1_2_LPUART1_USB_LPTIM1_TSC_TIM2_21_22	= 0
+	AF1_SPI1_2_I2S2_I2C1_TIM2_21						= 1
+	AF2_SPI1_2_I2S2_LPUART1_USART5_USB_LPTIM1_TIM2_3			= 2
+	AF3_I2C1_TSC								= 3
+	AF4_I2C1_USART1_2_LPUART1_TIM3_22					= 4
+	AF5_SPI2_I2S2_I2C2_USART1_TIM2_21_22					= 5
+	AF6_I2C1_2_LPUART1_USART4_5_TIM21					= 6
+	AF7_I2C3_LPUART1_COMP1_2_TIM3						= 7
+)
+```
+
+
+
+```go
+const (
+	ARR_MAX	= 0x10000
+	PSC_MAX	= 0x10000
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+
+	// Console UART (LPUSART1)
+	UART0	= &_UART0
+	_UART0	= UART{
+		Buffer:			NewRingBuffer(),
+		Bus:			stm32.LPUART1,
+		TxAltFuncSelector:	6,
+		RxAltFuncSelector:	6,
+	}
+
+	// Gps UART
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:			NewRingBuffer(),
+		Bus:			stm32.USART1,
+		TxAltFuncSelector:	0,
+		RxAltFuncSelector:	0,
+	}
+
+	// MPU9250 Nine-Axis (Gyro + Accelerometer + Compass)
+	I2C1	= &I2C{
+		Bus:			stm32.I2C1,
+		AltFuncSelector:	6,
+	}
+	I2C0	= I2C1
+
+	// SPI
+	SPI0	= &SPI{
+		Bus: stm32.SPI1,
+	}
+	SPI1	= SPI0
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	TIM2	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM2EN,
+		Device:		stm32.TIM2,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{
+				{PA0, AF2_SPI1_2_I2S2_LPUART1_USART5_USB_LPTIM1_TIM2_3},
+				{PA5, AF5_SPI2_I2S2_I2C2_USART1_TIM2_21_22},
+				{PA15, AF5_SPI2_I2S2_I2C2_USART1_TIM2_21_22},
+				{PE9, AF0_SYSTEM_SPI1_2_I2S2_USART1_2_LPUART1_USB_LPTIM1_TSC_TIM2_21_22},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA1, AF2_SPI1_2_I2S2_LPUART1_USART5_USB_LPTIM1_TIM2_3},
+				{PB3, AF2_SPI1_2_I2S2_LPUART1_USART5_USB_LPTIM1_TIM2_3},
+				{PE10, AF0_SYSTEM_SPI1_2_I2S2_USART1_2_LPUART1_USB_LPTIM1_TSC_TIM2_21_22},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA2, AF2_SPI1_2_I2S2_LPUART1_USART5_USB_LPTIM1_TIM2_3},
+				{PB10, AF2_SPI1_2_I2S2_LPUART1_USART5_USB_LPTIM1_TIM2_3},
+				{PE11, AF0_SYSTEM_SPI1_2_I2S2_USART1_2_LPUART1_USB_LPTIM1_TSC_TIM2_21_22},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA3, AF2_SPI1_2_I2S2_LPUART1_USART5_USB_LPTIM1_TIM2_3},
+				{PB11, AF2_SPI1_2_I2S2_LPUART1_USART5_USB_LPTIM1_TIM2_3},
+				{PE12, AF0_SYSTEM_SPI1_2_I2S2_USART1_2_LPUART1_USB_LPTIM1_TSC_TIM2_21_22},
+			}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM3	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM3EN,
+		Device:		stm32.TIM3,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{
+				{PA6, AF2_SPI1_2_I2S2_LPUART1_USART5_USB_LPTIM1_TIM2_3},
+				{PB4, AF2_SPI1_2_I2S2_LPUART1_USART5_USB_LPTIM1_TIM2_3},
+				{PC6, AF2_SPI1_2_I2S2_LPUART1_USART5_USB_LPTIM1_TIM2_3},
+				{PE3, AF2_SPI1_2_I2S2_LPUART1_USART5_USB_LPTIM1_TIM2_3},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA7, AF2_SPI1_2_I2S2_LPUART1_USART5_USB_LPTIM1_TIM2_3},
+				{PB5, AF4_I2C1_USART1_2_LPUART1_TIM3_22},
+				{PC7, AF2_SPI1_2_I2S2_LPUART1_USART5_USB_LPTIM1_TIM2_3},
+				{PE4, AF2_SPI1_2_I2S2_LPUART1_USART5_USB_LPTIM1_TIM2_3},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PB0, AF2_SPI1_2_I2S2_LPUART1_USART5_USB_LPTIM1_TIM2_3},
+				{PC8, AF2_SPI1_2_I2S2_LPUART1_USART5_USB_LPTIM1_TIM2_3},
+				{PE5, AF2_SPI1_2_I2S2_LPUART1_USART5_USB_LPTIM1_TIM2_3},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PB1, AF2_SPI1_2_I2S2_LPUART1_USART5_USB_LPTIM1_TIM2_3},
+				{PC9, AF2_SPI1_2_I2S2_LPUART1_USART5_USB_LPTIM1_TIM2_3},
+				{PE6, AF2_SPI1_2_I2S2_LPUART1_USART5_USB_LPTIM1_TIM2_3},
+			}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM6	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM6EN,
+		Device:		stm32.TIM6,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM7	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM7EN,
+		Device:		stm32.TIM7,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM21	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM21EN,
+		Device:		stm32.TIM21,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{
+				{PA2, AF0_SYSTEM_SPI1_2_I2S2_USART1_2_LPUART1_USB_LPTIM1_TSC_TIM2_21_22},
+				{PB13, AF6_I2C1_2_LPUART1_USART4_5_TIM21},
+				{PD0, AF0_SYSTEM_SPI1_2_I2S2_USART1_2_LPUART1_USB_LPTIM1_TSC_TIM2_21_22},
+				{PE5, AF0_SYSTEM_SPI1_2_I2S2_USART1_2_LPUART1_USB_LPTIM1_TSC_TIM2_21_22},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA3, AF0_SYSTEM_SPI1_2_I2S2_USART1_2_LPUART1_USB_LPTIM1_TSC_TIM2_21_22},
+				{PB14, AF6_I2C1_2_LPUART1_USART4_5_TIM21},
+				{PD7, AF1_SPI1_2_I2S2_I2C1_TIM2_21},
+				{PE6, AF0_SYSTEM_SPI1_2_I2S2_USART1_2_LPUART1_USB_LPTIM1_TSC_TIM2_21_22},
+			}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM22	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM22EN,
+		Device:		stm32.TIM2,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{
+				{PA6, AF5_SPI2_I2S2_I2C2_USART1_TIM2_21_22},
+				{PB4, AF4_I2C1_USART1_2_LPUART1_TIM3_22},
+				{PC6, AF0_SYSTEM_SPI1_2_I2S2_USART1_2_LPUART1_USB_LPTIM1_TSC_TIM2_21_22},
+				{PE3, AF0_SYSTEM_SPI1_2_I2S2_USART1_2_LPUART1_USB_LPTIM1_TSC_TIM2_21_22},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA7, AF5_SPI2_I2S2_I2C2_USART1_TIM2_21_22},
+				{PB5, AF4_I2C1_USART1_2_LPUART1_TIM3_22},
+				{PC7, AF0_SYSTEM_SPI1_2_I2S2_USART1_2_LPUART1_USB_LPTIM1_TSC_TIM2_21_22},
+				{PE4, AF0_SYSTEM_SPI1_2_I2S2_USART1_2_LPUART1_USB_LPTIM1_TSC_TIM2_21_22},
+			}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+)
+```
+
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself.
+
+The length of the device ID for STM32 is 12 bytes (96 bits).
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of cryptographically secure random data
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type ChannelCallback
+
+```go
+type ChannelCallback func(channel uint8)
+```
+
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*stm32.I2C_Type
+	AltFuncSelector	uint8
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration
+
+
+### func (Pin) ConfigureAltFunc
+
+```go
+func (p Pin) ConfigureAltFunc(config PinConfig, altFunc uint8)
+```
+
+Configure this pin with the given configuration including alternate
+
+	function mapping if necessary.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+PortMaskClear returns the register and mask to disable a given port. This can
+be used to implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+PortMaskSet returns the register and mask to enable a given GPIO pin. This
+can be used to implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetAltFunc
+
+```go
+func (p Pin) SetAltFunc(af uint8)
+```
+
+SetAltFunc maps the given alternative function to the I/O pin
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+---------- General pin operations ----------
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinFunction
+
+```go
+type PinFunction struct {
+	Pin	Pin
+	AltFunc	uint8
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus		*stm32.SPI_Type
+	AltFuncSelector	uint8
+}
+```
+
+SPI on the STM32Fxxx using MODER / alternate function pins
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the STM32 SPI1 interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type TIM
+
+```go
+type TIM struct {
+	EnableRegister	*volatile.Register32
+	EnableFlag	uint32
+	Device		*stm32.TIM_Type
+	Channels	[4]TimerChannel
+	UpInterrupt	interrupt.Interrupt
+	OCInterrupt	interrupt.Interrupt
+
+	wraparoundCallback	TimerCallback
+	channelCallbacks	[4]ChannelCallback
+
+	busFreq	uint64
+}
+```
+
+
+
+
+### func (*TIM) Channel
+
+```go
+func (t *TIM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*TIM) Configure
+
+```go
+func (t *TIM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+
+
+### func (*TIM) Count
+
+```go
+func (t *TIM) Count() uint32
+```
+
+
+
+### func (*TIM) Set
+
+```go
+func (t *TIM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	t.Set(ch, t.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*TIM) SetInverting
+
+```go
+func (t *TIM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TIM) SetMatchInterrupt
+
+```go
+func (t *TIM) SetMatchInterrupt(channel uint8, callback ChannelCallback) error
+```
+
+Sets a callback to be called when a channel reaches it's set-point.
+
+For example, if `t.Set(ch, t.Top() / 4)` is used then the callback will
+be called every quarter-period of the timer's base Period.
+
+
+### func (*TIM) SetPeriod
+
+```go
+func (t *TIM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TIM) SetWraparoundInterrupt
+
+```go
+func (t *TIM) SetWraparoundInterrupt(callback TimerCallback) error
+```
+
+SetWraparoundInterrupt configures a callback to be called each
+time the timer 'wraps-around'.
+
+For example, if `Configure(PWMConfig{Period:1000000})` is used,
+to set the timer period to 1ms, this callback will be called every
+1ms.
+
+
+### func (*TIM) Top
+
+```go
+func (t *TIM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+### func (*TIM) Unset
+
+```go
+func (t *TIM) Unset(channel uint8)
+```
+
+Unset disables a channel, including any configured interrupts.
+
+
+
+
+## type TimerCallback
+
+```go
+type TimerCallback func()
+```
+
+
+
+
+
+
+## type TimerChannel
+
+```go
+type TimerChannel struct {
+	Pins []PinFunction
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer			*RingBuffer
+	Bus			*stm32.USART_Type
+	Interrupt		interrupt.Interrupt
+	TxAltFuncSelector	uint8
+	RxAltFuncSelector	uint8
+
+	// Registers specific to the chip
+	rxReg		*volatile.Register32
+	txReg		*volatile.Register32
+	statusReg	*volatile.Register32
+	txEmptyFlag	uint32
+}
+```
+
+UART representation
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART. Defer to chip-specific
+routines for calculation
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/lorae5.md b/content/docs/reference/microcontrollers/machine/lorae5.md
new file mode 100644
index 00000000..1eba25a6
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/lorae5.md
@@ -0,0 +1,1500 @@
+
+---
+title: lorae5
+---
+
+
+## Constants
+
+```go
+const (
+	// We assume a LED is connected on PB5
+	LED	= PB5	// Default LED
+
+	// Set the POWER_EN3V3 pin to high to turn
+	// on the 3.3V power for all peripherals
+	POWER_EN3V3	= PA9
+
+	// Set the POWER_EN5V pin to high to turn
+	// on the 5V bus power for all peripherals
+	POWER_EN5V	= PB10
+)
+```
+
+
+
+```go
+const (
+	SPI0_NSS_PIN	= PA4
+	SPI0_SCK_PIN	= PA5
+	SPI0_SDO_PIN	= PA6
+	SPI0_SDI_PIN	= PA7
+)
+```
+
+SubGhz (SPI3)
+
+
+```go
+const (
+	// MCU USART1
+	UART1_TX_PIN	= PB6
+	UART1_RX_PIN	= PB7
+
+	// MCU USART2
+	UART2_TX_PIN	= PA2
+	UART2_RX_PIN	= PA3
+
+	// DEFAULT USART
+	UART_TX_PIN	= UART1_TX_PIN
+	UART_RX_PIN	= UART1_RX_PIN
+
+	// I2C2 pins
+	I2C2_SCL_PIN	= PB15
+	I2C2_SDA_PIN	= PA15
+	I2C2_ALT_FUNC	= 4
+
+	// I2C0 alias for I2C2
+	I2C0_SDA_PIN	= I2C2_SDA_PIN
+	I2C0_SCL_PIN	= I2C2_SCL_PIN
+)
+```
+
+UARTS
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinRising	PinChange	= 1 << iota
+	PinFalling
+	PinToggle	= PinRising | PinFalling
+)
+```
+
+
+
+```go
+const (
+	MAX_NBYTE_SIZE	= 255
+
+	// 100ms delay = 100e6ns / 16ns
+	// In runtime_stm32_timers.go, tick is fixed at 16ns per tick
+	TIMEOUT_TICKS	= 100e6 / 16
+
+	I2C_NO_STARTSTOP		= 0x0
+	I2C_GENERATE_START_WRITE	= 0x80000000 | stm32.I2C_CR2_START
+	I2C_GENERATE_START_READ		= 0x80000000 | stm32.I2C_CR2_START | stm32.I2C_CR2_RD_WRN
+	I2C_GENERATE_STOP		= 0x80000000 | stm32.I2C_CR2_STOP
+)
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (32.768s)
+	//
+	// Timeout is based on 12-bit counter with /256 divider on
+	// 32.768kHz clock.  See 21.3.3 of RM0090 for table.
+	WatchdogMaxTimeout = ((0xfff + 1) * 256 * 1024) / 32768
+)
+```
+
+
+
+```go
+const (
+	// Mode Flag
+	PinOutput		PinMode	= 0
+	PinInput		PinMode	= PinInputFloating
+	PinInputFloating	PinMode	= 1
+	PinInputPulldown	PinMode	= 2
+	PinInputPullup		PinMode	= 3
+
+	// for UART
+	PinModeUARTTX	PinMode	= 4
+	PinModeUARTRX	PinMode	= 5
+
+	// for I2C
+	PinModeI2CSCL	PinMode	= 6
+	PinModeI2CSDA	PinMode	= 7
+
+	// for SPI
+	PinModeSPICLK	PinMode	= 8
+	PinModeSPISDO	PinMode	= 9
+	PinModeSPISDI	PinMode	= 10
+
+	// for analog/ADC
+	PinInputAnalog	PinMode	= 11
+
+	// for PWM
+	PinModePWMOutput	PinMode	= 12
+)
+```
+
+
+
+```go
+const RNG_MAX_READ_RETRIES = 1000
+```
+
+
+
+```go
+const PWM_MODE1 = 0x6
+```
+
+
+
+```go
+const (
+	AF0_SYSTEM		= 0
+	AF1_TIM1_2_LPTIM1	= 1
+	AF2_TIM1_2		= 2
+	AF3_SPIS2_TIM1_LPTIM3	= 3
+	AF4_I2C1_2_3		= 4
+	AF5_SPI1_SPI2S2		= 5
+	AF6_RF			= 6
+	AF7_USART1_2		= 7
+	AF8_LPUART1		= 8
+	AF12_COMP1_2_TIM1	= 12
+	AF13_DEBUG		= 13
+	AF14_TIM2_16_17_LPTIM2	= 14
+	AF15_EVENTOUT		= 15
+)
+```
+
+
+
+```go
+const (
+	SYSCLK		= 48e6
+	APB1_TIM_FREQ	= SYSCLK
+	APB2_TIM_FREQ	= SYSCLK
+)
+```
+
+
+
+```go
+const (
+	PA0	= portA + 0
+	PA1	= portA + 1
+	PA2	= portA + 2
+	PA3	= portA + 3
+	PA4	= portA + 4
+	PA5	= portA + 5
+	PA6	= portA + 6
+	PA7	= portA + 7
+	PA8	= portA + 8
+	PA9	= portA + 9
+	PA10	= portA + 10
+	PA11	= portA + 11
+	PA12	= portA + 12
+	PA13	= portA + 13
+	PA14	= portA + 14
+	PA15	= portA + 15
+
+	PB0	= portB + 0
+	PB1	= portB + 1
+	PB2	= portB + 2
+	PB3	= portB + 3
+	PB4	= portB + 4
+	PB5	= portB + 5
+	PB6	= portB + 6
+	PB7	= portB + 7
+	PB8	= portB + 8
+	PB9	= portB + 9
+	PB10	= portB + 10
+	PB11	= portB + 11
+	PB12	= portB + 12
+	PB13	= portB + 13
+	PB14	= portB + 14
+	PB15	= portB + 15
+
+	PC0	= portC + 0
+	PC1	= portC + 1
+	PC2	= portC + 2
+	PC3	= portC + 3
+	PC4	= portC + 4
+	PC5	= portC + 5
+	PC6	= portC + 6
+	PC7	= portC + 7
+	PC8	= portC + 8
+	PC9	= portC + 9
+	PC10	= portC + 10
+	PC11	= portC + 11
+	PC12	= portC + 12
+	PC13	= portC + 13
+	PC14	= portC + 14
+	PC15	= portC + 15
+
+	PH3	= portH + 3
+)
+```
+
+
+
+```go
+const (
+	ARR_MAX	= 0x10000
+	PSC_MAX	= 0x10000
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	// Console UART
+	UART0	= &_UART0
+	_UART0	= UART{
+		Buffer:			NewRingBuffer(),
+		Bus:			stm32.USART1,
+		TxAltFuncSelector:	AF7_USART1_2,
+		RxAltFuncSelector:	AF7_USART1_2,
+	}
+	DefaultUART	= UART0
+
+	// Since we treat UART1 as zero, let's also call it by the real name
+	UART1	= UART0
+
+	// UART2
+	UART2	= &_UART2
+	_UART2	= UART{
+		Buffer:			NewRingBuffer(),
+		Bus:			stm32.USART2,
+		TxAltFuncSelector:	AF7_USART1_2,
+		RxAltFuncSelector:	AF7_USART1_2,
+	}
+
+	// I2C Busses
+	I2C2	= &I2C{
+		Bus:			stm32.I2C2,
+		AltFuncSelector:	I2C2_ALT_FUNC,
+	}
+
+	// Set "default" I2C bus to I2C2
+	I2C0	= I2C2
+
+	// SPI
+	SPI3	= &SPI{
+		Bus: stm32.SPI3,
+	}
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	TIM1	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM1EN,
+		Device:		stm32.TIM1,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA8, AF1_TIM1_2_LPTIM1}}},
+			TimerChannel{Pins: []PinFunction{{PA9, AF1_TIM1_2_LPTIM1}}},
+			TimerChannel{Pins: []PinFunction{{PA10, AF1_TIM1_2_LPTIM1}}},
+			TimerChannel{Pins: []PinFunction{{PA11, AF1_TIM1_2_LPTIM1}}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+	TIM2	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR1,
+		EnableFlag:	stm32.RCC_APB1ENR1_TIM2EN,
+		Device:		stm32.TIM2,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA0, AF1_TIM1_2_LPTIM1}, {PA5, AF1_TIM1_2_LPTIM1}, {PA15, AF1_TIM1_2_LPTIM1}}},
+			TimerChannel{Pins: []PinFunction{{PA1, AF1_TIM1_2_LPTIM1}, {PB3, AF1_TIM1_2_LPTIM1}}},
+			TimerChannel{Pins: []PinFunction{{PA2, AF1_TIM1_2_LPTIM1}, {PB10, AF1_TIM1_2_LPTIM1}}},
+			TimerChannel{Pins: []PinFunction{{PA3, AF1_TIM1_2_LPTIM1}, {PB11, AF1_TIM1_2_LPTIM1}}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+	TIM16	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM16EN,
+		Device:		stm32.TIM16,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA6, AF14_TIM2_16_17_LPTIM2}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+	TIM17	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM17EN,
+		Device:		stm32.TIM17,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA7, AF1_TIM1_2_LPTIM1}, {PB9, AF1_TIM1_2_LPTIM1}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+)
+```
+
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself.
+
+The length of the device ID for STM32 is 12 bytes (96 bits).
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of cryptographically secure random data
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type ChannelCallback
+
+```go
+type ChannelCallback func(channel uint8)
+```
+
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*stm32.I2C_Type
+	AltFuncSelector	uint8
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration
+
+
+### func (Pin) ConfigureAltFunc
+
+```go
+func (p Pin) ConfigureAltFunc(config PinConfig, altFunc uint8)
+```
+
+Configure this pin with the given configuration including alternate
+
+	function mapping if necessary.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+PortMaskClear returns the register and mask to disable a given port. This can
+be used to implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+PortMaskSet returns the register and mask to enable a given GPIO pin. This
+can be used to implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetAltFunc
+
+```go
+func (p Pin) SetAltFunc(af uint8)
+```
+
+SetAltFunc maps the given alternative function to the I/O pin
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+---------- General pin operations ----------
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinFunction
+
+```go
+type PinFunction struct {
+	Pin	Pin
+	AltFunc	uint8
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus		*stm32.SPI_Type
+	AltFuncSelector	uint8
+}
+```
+
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the STM32 SPI1 interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type TIM
+
+```go
+type TIM struct {
+	EnableRegister	*volatile.Register32
+	EnableFlag	uint32
+	Device		*stm32.TIM_Type
+	Channels	[4]TimerChannel
+	UpInterrupt	interrupt.Interrupt
+	OCInterrupt	interrupt.Interrupt
+
+	wraparoundCallback	TimerCallback
+	channelCallbacks	[4]ChannelCallback
+
+	busFreq	uint64
+}
+```
+
+
+
+
+### func (*TIM) Channel
+
+```go
+func (t *TIM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*TIM) Configure
+
+```go
+func (t *TIM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+
+
+### func (*TIM) Count
+
+```go
+func (t *TIM) Count() uint32
+```
+
+
+
+### func (*TIM) Set
+
+```go
+func (t *TIM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	t.Set(ch, t.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*TIM) SetInverting
+
+```go
+func (t *TIM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TIM) SetMatchInterrupt
+
+```go
+func (t *TIM) SetMatchInterrupt(channel uint8, callback ChannelCallback) error
+```
+
+Sets a callback to be called when a channel reaches it's set-point.
+
+For example, if `t.Set(ch, t.Top() / 4)` is used then the callback will
+be called every quarter-period of the timer's base Period.
+
+
+### func (*TIM) SetPeriod
+
+```go
+func (t *TIM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TIM) SetWraparoundInterrupt
+
+```go
+func (t *TIM) SetWraparoundInterrupt(callback TimerCallback) error
+```
+
+SetWraparoundInterrupt configures a callback to be called each
+time the timer 'wraps-around'.
+
+For example, if `Configure(PWMConfig{Period:1000000})` is used,
+to set the timer period to 1ms, this callback will be called every
+1ms.
+
+
+### func (*TIM) Top
+
+```go
+func (t *TIM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+### func (*TIM) Unset
+
+```go
+func (t *TIM) Unset(channel uint8)
+```
+
+Unset disables a channel, including any configured interrupts.
+
+
+
+
+## type TimerCallback
+
+```go
+type TimerCallback func()
+```
+
+
+
+
+
+
+## type TimerChannel
+
+```go
+type TimerChannel struct {
+	Pins []PinFunction
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer			*RingBuffer
+	Bus			*stm32.USART_Type
+	Interrupt		interrupt.Interrupt
+	TxAltFuncSelector	uint8
+	RxAltFuncSelector	uint8
+
+	// Registers specific to the chip
+	rxReg		*volatile.Register32
+	txReg		*volatile.Register32
+	statusReg	*volatile.Register32
+	txEmptyFlag	uint32
+}
+```
+
+UART representation
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART. Defer to chip-specific
+routines for calculation
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/m5stack-core2.md b/content/docs/reference/microcontrollers/machine/m5stack-core2.md
new file mode 100644
index 00000000..3a477935
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/m5stack-core2.md
@@ -0,0 +1,1009 @@
+
+---
+title: m5stack-core2
+---
+
+
+## Constants
+
+```go
+const (
+	IO0	= GPIO0
+	IO1	= GPIO1	// U0TXD
+	IO2	= GPIO2
+	IO3	= GPIO3	// U0RXD
+	IO4	= GPIO4
+	IO5	= GPIO5
+	IO6	= GPIO6		// SD_CLK
+	IO7	= GPIO7		// SD_DATA0
+	IO8	= GPIO8		// SD_DATA1
+	IO9	= GPIO9		// SD_DATA2
+	IO10	= GPIO10	// SD_DATA3
+	IO11	= GPIO11	// SD_CMD
+	IO12	= GPIO12
+	IO13	= GPIO13	// U0RXD
+	IO14	= GPIO14	// U1TXD
+	IO15	= GPIO15
+	IO16	= GPIO16
+	IO17	= GPIO17
+	IO18	= GPIO18	// SPI0_SCK
+	IO19	= GPIO19
+	IO21	= GPIO21	// SDA0
+	IO22	= GPIO22	// SCL0
+	IO23	= GPIO23	// SPI0_SDO
+	IO25	= GPIO25
+	IO26	= GPIO26
+	IO27	= GPIO27
+	IO32	= GPIO32	// SDA1
+	IO33	= GPIO33	// SCL1
+	IO34	= GPIO34
+	IO35	= GPIO35	// ADC1
+	IO36	= GPIO36	// ADC2
+	IO38	= GPIO38	// SPI0_SDI
+	IO39	= GPIO39
+)
+```
+
+
+
+```go
+const (
+	SPI0_SCK_PIN	= IO18
+	SPI0_SDO_PIN	= IO23
+	SPI0_SDI_PIN	= IO38
+	SPI0_CS0_PIN	= IO5
+
+	// LCD (ILI9342C)
+	LCD_SCK_PIN	= SPI0_SCK_PIN
+	LCD_SDO_PIN	= SPI0_SDO_PIN
+	LCD_SDI_PIN	= SPI0_SDI_PIN
+	LCD_SS_PIN	= SPI0_CS0_PIN
+	LCD_DC_PIN	= IO15
+
+	// SD CARD
+	SDCARD_SCK_PIN	= SPI0_SCK_PIN
+	SDCARD_SDO_PIN	= SPI0_SDO_PIN
+	SDCARD_SDI_PIN	= SPI0_SDI_PIN
+	SDCARD_SS_PIN	= IO4
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	// Internal I2C (AXP192 / FT6336U / BM8563 / MPU6886)
+	SDA0_PIN	= IO21
+	SCL0_PIN	= IO22
+
+	// External I2C (PORT A)
+	SDA1_PIN	= IO32
+	SCL1_PIN	= IO33
+
+	SDA_PIN	= SDA1_PIN
+	SCL_PIN	= SCL1_PIN
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	ADC1	Pin	= IO35
+	ADC2	Pin	= IO36
+)
+```
+
+ADC pins
+
+
+```go
+const (
+	DAC1	Pin	= IO25
+	DAC2	Pin	= IO26
+)
+```
+
+DAC pins
+
+
+```go
+const (
+	// UART0 (CP2104)
+	UART0_TX_PIN	= IO1
+	UART0_RX_PIN	= IO3
+
+	UART1_TX_PIN	= IO14
+	UART1_RX_PIN	= IO13
+
+	UART_TX_PIN	= UART0_TX_PIN
+	UART_RX_PIN	= UART0_RX_PIN
+)
+```
+
+UART pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinOutput	PinMode	= iota
+	PinInput
+	PinInputPullup
+	PinInputPulldown
+)
+```
+
+
+
+```go
+const (
+	GPIO0	Pin	= 0
+	GPIO1	Pin	= 1
+	GPIO2	Pin	= 2
+	GPIO3	Pin	= 3
+	GPIO4	Pin	= 4
+	GPIO5	Pin	= 5
+	GPIO6	Pin	= 6
+	GPIO7	Pin	= 7
+	GPIO8	Pin	= 8
+	GPIO9	Pin	= 9
+	GPIO10	Pin	= 10
+	GPIO11	Pin	= 11
+	GPIO12	Pin	= 12
+	GPIO13	Pin	= 13
+	GPIO14	Pin	= 14
+	GPIO15	Pin	= 15
+	GPIO16	Pin	= 16
+	GPIO17	Pin	= 17
+	GPIO18	Pin	= 18
+	GPIO19	Pin	= 19
+	GPIO21	Pin	= 21
+	GPIO22	Pin	= 22
+	GPIO23	Pin	= 23
+	GPIO25	Pin	= 25
+	GPIO26	Pin	= 26
+	GPIO27	Pin	= 27
+	GPIO32	Pin	= 32
+	GPIO33	Pin	= 33
+	GPIO34	Pin	= 34
+	GPIO35	Pin	= 35
+	GPIO36	Pin	= 36
+	GPIO37	Pin	= 37
+	GPIO38	Pin	= 38
+	GPIO39	Pin	= 39
+)
+```
+
+Hardware pin numbers
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	ErrInvalidSPIBus = errors.New("machine: invalid SPI bus")
+)
+```
+
+
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	UART0	= &_UART0
+	_UART0	= UART{Bus: esp.UART0, Buffer: NewRingBuffer()}
+	UART1	= &_UART1
+	_UART1	= UART{Bus: esp.UART1, Buffer: NewRingBuffer()}
+	UART2	= &_UART2
+	_UART2	= UART{Bus: esp.UART2, Buffer: NewRingBuffer()}
+)
+```
+
+
+
+```go
+var (
+	// SPI0 and SPI1 are reserved for use by the caching system etc.
+	SPI2	= &SPI{esp.SPI2}
+	SPI3	= &SPI{esp.SPI3}
+)
+```
+
+
+
+```go
+var (
+	I2C0	= &I2C{Bus: esp.I2C0, funcSCL: 29, funcSDA: 30}
+	I2C1	= &I2C{Bus: esp.I2C1, funcSCL: 95, funcSDA: 96}
+)
+```
+
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+CPUFrequency returns the current CPU frequency of the chip.
+Currently it is a fixed frequency but it may allow changing in the future.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus			*esp.I2C_Type
+	funcSCL, funcSDA	uint32
+	config			I2CConfig
+}
+```
+
+
+
+
+### func (*I2C) CheckDevice
+
+```go
+func (i2c *I2C) CheckDevice(addr uint16) bool
+```
+
+CheckDevice does an empty I2C transaction at the specified address.
+This can be used to find out if any device with that address is
+connected, e.g. for enumerating all devices on the bus.
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) (err error)
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32	// in Hz
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+Warning: only use this on an output pin!
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+Warning: only use this on an output pin!
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus *esp.SPI_Type
+}
+```
+
+Serial Peripheral Interface on the ESP32.
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure and make the SPI peripheral ready to use.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface. If you need to
+transfer larger amounts of data, Tx will be faster.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+This is accomplished by sending zero bits if r is bigger than w or discarding
+the incoming data if w is bigger than r.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig configures a SPI peripheral on the ESP32. Make sure to set at least
+SCK, SDO and SDI (possibly to NoPin if not in use). The default for LSBFirst
+(false) and Mode (0) are good for most applications. The frequency defaults
+to 1MHz if not set but can be configured up to 40MHz. Possible values are
+40MHz and integer divisions from 40MHz such as 20MHz, 13.3MHz, 10MHz, 8MHz,
+etc.
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Bus	*esp.UART_Type
+	Buffer	*RingBuffer
+}
+```
+
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/m5stack.md b/content/docs/reference/microcontrollers/machine/m5stack.md
new file mode 100644
index 00000000..de504120
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/m5stack.md
@@ -0,0 +1,1022 @@
+
+---
+title: m5stack
+---
+
+
+## Constants
+
+```go
+const (
+	IO0	= GPIO0
+	IO1	= GPIO1
+	IO2	= GPIO2
+	IO3	= GPIO3
+	IO4	= GPIO4
+	IO5	= GPIO5
+	IO6	= GPIO6
+	IO7	= GPIO7
+	IO8	= GPIO8
+	IO9	= GPIO9
+	IO10	= GPIO10
+	IO11	= GPIO11
+	IO12	= GPIO12
+	IO13	= GPIO13
+	IO14	= GPIO14
+	IO15	= GPIO15
+	IO16	= GPIO16
+	IO17	= GPIO17
+	IO18	= GPIO18
+	IO19	= GPIO19
+	IO21	= GPIO21
+	IO22	= GPIO22
+	IO23	= GPIO23
+	IO25	= GPIO25
+	IO26	= GPIO26
+	IO27	= GPIO27
+	IO32	= GPIO32
+	IO33	= GPIO33
+	IO34	= GPIO34
+	IO35	= GPIO35
+	IO36	= GPIO36
+	IO37	= GPIO37
+	IO38	= GPIO38
+	IO39	= GPIO39
+)
+```
+
+
+
+```go
+const (
+	// Buttons
+	BUTTON_A	= IO39
+	BUTTON_B	= IO38
+	BUTTON_C	= IO37
+	BUTTON		= BUTTON_A
+
+	// Speaker
+	SPEAKER_PIN	= IO25
+)
+```
+
+
+
+```go
+const (
+	SPI0_SCK_PIN	= IO18
+	SPI0_SDO_PIN	= IO23
+	SPI0_SDI_PIN	= IO19
+	SPI0_CS0_PIN	= IO14
+
+	// LCD (ILI9342C)
+	LCD_SCK_PIN	= SPI0_SCK_PIN
+	LCD_SDO_PIN	= SPI0_SDO_PIN
+	LCD_SDI_PIN	= SPI0_SDI_PIN	// NoPin ?
+	LCD_SS_PIN	= SPI0_CS0_PIN
+	LCD_DC_PIN	= IO27
+	LCD_RST_PIN	= IO33
+	LCD_BL_PIN	= IO32
+
+	// SD CARD
+	SDCARD_SCK_PIN	= SPI0_SCK_PIN
+	SDCARD_SDO_PIN	= SPI0_SDO_PIN
+	SDCARD_SDI_PIN	= SPI0_SDI_PIN
+	SDCARD_SS_PIN	= IO4
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	SDA0_PIN	= IO21
+	SCL0_PIN	= IO22
+
+	SDA_PIN	= SDA0_PIN
+	SCL_PIN	= SCL0_PIN
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	ADC1	Pin	= IO35
+	ADC2	Pin	= IO36
+)
+```
+
+ADC pins
+
+
+```go
+const (
+	DAC1	Pin	= IO25
+	DAC2	Pin	= IO26
+)
+```
+
+DAC pins
+
+
+```go
+const (
+	// UART0 (CP2104)
+	UART0_TX_PIN	= IO1
+	UART0_RX_PIN	= IO3
+
+	UART1_TX_PIN	= IO17
+	UART1_RX_PIN	= IO16
+
+	UART_TX_PIN	= UART0_TX_PIN
+	UART_RX_PIN	= UART0_RX_PIN
+)
+```
+
+UART pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinOutput	PinMode	= iota
+	PinInput
+	PinInputPullup
+	PinInputPulldown
+)
+```
+
+
+
+```go
+const (
+	GPIO0	Pin	= 0
+	GPIO1	Pin	= 1
+	GPIO2	Pin	= 2
+	GPIO3	Pin	= 3
+	GPIO4	Pin	= 4
+	GPIO5	Pin	= 5
+	GPIO6	Pin	= 6
+	GPIO7	Pin	= 7
+	GPIO8	Pin	= 8
+	GPIO9	Pin	= 9
+	GPIO10	Pin	= 10
+	GPIO11	Pin	= 11
+	GPIO12	Pin	= 12
+	GPIO13	Pin	= 13
+	GPIO14	Pin	= 14
+	GPIO15	Pin	= 15
+	GPIO16	Pin	= 16
+	GPIO17	Pin	= 17
+	GPIO18	Pin	= 18
+	GPIO19	Pin	= 19
+	GPIO21	Pin	= 21
+	GPIO22	Pin	= 22
+	GPIO23	Pin	= 23
+	GPIO25	Pin	= 25
+	GPIO26	Pin	= 26
+	GPIO27	Pin	= 27
+	GPIO32	Pin	= 32
+	GPIO33	Pin	= 33
+	GPIO34	Pin	= 34
+	GPIO35	Pin	= 35
+	GPIO36	Pin	= 36
+	GPIO37	Pin	= 37
+	GPIO38	Pin	= 38
+	GPIO39	Pin	= 39
+)
+```
+
+Hardware pin numbers
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	ErrInvalidSPIBus = errors.New("machine: invalid SPI bus")
+)
+```
+
+
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	UART0	= &_UART0
+	_UART0	= UART{Bus: esp.UART0, Buffer: NewRingBuffer()}
+	UART1	= &_UART1
+	_UART1	= UART{Bus: esp.UART1, Buffer: NewRingBuffer()}
+	UART2	= &_UART2
+	_UART2	= UART{Bus: esp.UART2, Buffer: NewRingBuffer()}
+)
+```
+
+
+
+```go
+var (
+	// SPI0 and SPI1 are reserved for use by the caching system etc.
+	SPI2	= &SPI{esp.SPI2}
+	SPI3	= &SPI{esp.SPI3}
+)
+```
+
+
+
+```go
+var (
+	I2C0	= &I2C{Bus: esp.I2C0, funcSCL: 29, funcSDA: 30}
+	I2C1	= &I2C{Bus: esp.I2C1, funcSCL: 95, funcSDA: 96}
+)
+```
+
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+CPUFrequency returns the current CPU frequency of the chip.
+Currently it is a fixed frequency but it may allow changing in the future.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus			*esp.I2C_Type
+	funcSCL, funcSDA	uint32
+	config			I2CConfig
+}
+```
+
+
+
+
+### func (*I2C) CheckDevice
+
+```go
+func (i2c *I2C) CheckDevice(addr uint16) bool
+```
+
+CheckDevice does an empty I2C transaction at the specified address.
+This can be used to find out if any device with that address is
+connected, e.g. for enumerating all devices on the bus.
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) (err error)
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32	// in Hz
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+Warning: only use this on an output pin!
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+Warning: only use this on an output pin!
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus *esp.SPI_Type
+}
+```
+
+Serial Peripheral Interface on the ESP32.
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure and make the SPI peripheral ready to use.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface. If you need to
+transfer larger amounts of data, Tx will be faster.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+This is accomplished by sending zero bits if r is bigger than w or discarding
+the incoming data if w is bigger than r.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig configures a SPI peripheral on the ESP32. Make sure to set at least
+SCK, SDO and SDI (possibly to NoPin if not in use). The default for LSBFirst
+(false) and Mode (0) are good for most applications. The frequency defaults
+to 1MHz if not set but can be configured up to 40MHz. Possible values are
+40MHz and integer divisions from 40MHz such as 20MHz, 13.3MHz, 10MHz, 8MHz,
+etc.
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Bus	*esp.UART_Type
+	Buffer	*RingBuffer
+}
+```
+
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/m5stamp-c3.md b/content/docs/reference/microcontrollers/machine/m5stamp-c3.md
new file mode 100644
index 00000000..0b47b0d6
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/m5stamp-c3.md
@@ -0,0 +1,936 @@
+
+---
+title: m5stamp-c3
+---
+
+
+## Constants
+
+```go
+const (
+	IO0	= GPIO0
+	IO1	= GPIO1
+	IO2	= GPIO2
+	IO3	= GPIO3
+	IO4	= GPIO4
+	IO5	= GPIO5
+	IO6	= GPIO6
+	IO7	= GPIO7
+	IO8	= GPIO8
+	IO9	= GPIO9
+	IO10	= GPIO10
+	IO11	= GPIO11
+	IO12	= GPIO12
+	IO13	= GPIO13
+	IO14	= GPIO14
+	IO15	= GPIO15
+	IO16	= GPIO16
+	IO17	= GPIO17
+	IO18	= GPIO18
+	IO19	= GPIO19
+	IO20	= GPIO20
+	IO21	= GPIO21
+
+	XTAL_32K_P	= IO0
+	XTAL_32K_N	= IO1
+	MTMS		= IO4
+	MTDI		= IO5
+	MTCK		= IO6
+	MTDO		= IO7
+	VDD_SPI		= IO11
+	SPIHD		= IO12
+	SPISP		= IO13
+	SPICS0		= IO14
+	SPICLK		= IO15
+	SPID		= IO16
+	SPIQ		= IO17
+	U0RXD		= IO20
+	U0TXD		= IO21
+
+	UART_TX_PIN	= U0TXD
+	UART_RX_PIN	= U0RXD
+)
+```
+
+
+
+```go
+const (
+	WS2812 = IO2
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinOutput	PinMode	= iota
+	PinInput
+	PinInputPullup
+	PinInputPulldown
+)
+```
+
+
+
+```go
+const (
+	GPIO0	Pin	= 0
+	GPIO1	Pin	= 1
+	GPIO2	Pin	= 2
+	GPIO3	Pin	= 3
+	GPIO4	Pin	= 4
+	GPIO5	Pin	= 5
+	GPIO6	Pin	= 6
+	GPIO7	Pin	= 7
+	GPIO8	Pin	= 8
+	GPIO9	Pin	= 9
+	GPIO10	Pin	= 10
+	GPIO11	Pin	= 11
+	GPIO12	Pin	= 12
+	GPIO13	Pin	= 13
+	GPIO14	Pin	= 14
+	GPIO15	Pin	= 15
+	GPIO16	Pin	= 16
+	GPIO17	Pin	= 17
+	GPIO18	Pin	= 18
+	GPIO19	Pin	= 19
+	GPIO20	Pin	= 20
+	GPIO21	Pin	= 21
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= iota + 1
+	PinFalling
+	PinToggle
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	SPI_MODE0	= uint8(0)
+	SPI_MODE1	= uint8(1)
+	SPI_MODE2	= uint8(2)
+	SPI_MODE3	= uint8(3)
+
+	FSPICLK_IN_IDX	= uint32(63)
+	FSPICLK_OUT_IDX	= uint32(63)
+	FSPIQ_IN_IDX	= uint32(64)
+	FSPIQ_OUT_IDX	= uint32(64)
+	FSPID_IN_IDX	= uint32(65)
+	FSPID_OUT_IDX	= uint32(65)
+	FSPIHD_IN_IDX	= uint32(66)
+	FSPIHD_OUT_IDX	= uint32(66)
+	FSPIWP_IN_IDX	= uint32(67)
+	FSPIWP_OUT_IDX	= uint32(67)
+	FSPICS0_IN_IDX	= uint32(68)
+	FSPICS0_OUT_IDX	= uint32(68)
+	FSPICS1_OUT_IDX	= uint32(69)
+	FSPICS2_OUT_IDX	= uint32(70)
+	FSPICS3_OUT_IDX	= uint32(71)
+	FSPICS4_OUT_IDX	= uint32(72)
+	FSPICS5_OUT_IDX	= uint32(73)
+)
+```
+
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	DefaultUART	= UART0
+
+	UART0	= &_UART0
+	_UART0	= UART{Bus: esp.UART0, Buffer: NewRingBuffer()}
+	UART1	= &_UART1
+	_UART1	= UART{Bus: esp.UART1, Buffer: NewRingBuffer()}
+
+	onceUart		= sync.Once{}
+	errSamePins		= errors.New("UART: invalid pin combination")
+	errWrongUART		= errors.New("UART: unsupported UARTn")
+	errWrongBitSize		= errors.New("UART: invalid data size")
+	errWrongStopBitSize	= errors.New("UART: invalid bit size")
+)
+```
+
+
+
+```go
+var (
+	_USBCDC	= &USB_DEVICE{
+		Bus: esp.USB_DEVICE,
+	}
+
+	USBCDC	Serialer	= _USBCDC
+)
+```
+
+
+
+```go
+var (
+	ErrInvalidSPIBus	= errors.New("machine: SPI bus is invalid")
+	ErrInvalidSPIMode	= errors.New("machine: SPI mode is invalid")
+)
+```
+
+
+
+```go
+var (
+	// SPI0 and SPI1 are reserved for use by the caching system etc.
+	SPI2 = &SPI{esp.SPI2}
+)
+```
+
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+CPUFrequency returns the current CPU frequency of the chip.
+Currently it is a fixed frequency but it may allow changing in the future.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (ret uint32, err error)
+```
+
+GetRNG returns 32-bit random numbers using the ESP32-C3 true random number generator,
+Random numbers are generated based on the thermal noise in the system and the
+asynchronous clock mismatch.
+For maximum entropy also make sure that the SAR_ADC is enabled.
+See esp32-c3_technical_reference_manual_en.pdf p.524
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when configured as an input or as
+an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+Warning: only use this on an output pin!
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+Warning: only use this on an output pin!
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) (err error)
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+You can pass a nil func to unset the pin change interrupt. If you do so,
+the change parameter is ignored and can be set to any value (such as 0).
+If the pin is already configured with a callback, you must first unset
+this pins interrupt before you can set a new callback.
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus *esp.SPI2_Type
+}
+```
+
+Serial Peripheral Interface on the ESP32-C3.
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure and make the SPI peripheral ready to use.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface. If you need to
+transfer larger amounts of data, Tx will be faster.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+This is accomplished by sending zero bits if r is bigger than w or discarding
+the incoming data if w is bigger than r.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin	// Serial Clock
+	SDO		Pin	// Serial Data Out (MOSI)
+	SDI		Pin	// Serial Data In  (MISO)
+	CS		Pin	// Chip Select (optional)
+	LSBFirst	bool	// MSB is default
+	Mode		uint8	// SPI_MODE0 is default
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Bus			*esp.UART_Type
+	Buffer			*RingBuffer
+	ParityErrorDetected	bool	// set when parity error detected
+	DataErrorDetected	bool	// set when data corruption detected
+	DataOverflowDetected	bool	// set when data overflow detected in UART FIFO buffer or RingBuffer
+}
+```
+
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(baudRate uint32)
+```
+
+
+
+### func (*UART) SetFormat
+
+```go
+func (uart *UART) SetFormat(dataBits, stopBits int, parity UARTParity) error
+```
+
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USB_DEVICE
+
+```go
+type USB_DEVICE struct {
+	Bus *esp.USB_DEVICE_Type
+}
+```
+
+USB Serial/JTAG Controller
+See esp32-c3_technical_reference_manual_en.pdf
+pg. 736
+
+
+
+### func (*USB_DEVICE) Buffered
+
+```go
+func (usbdev *USB_DEVICE) Buffered() int
+```
+
+
+
+### func (*USB_DEVICE) Configure
+
+```go
+func (usbdev *USB_DEVICE) Configure(config UARTConfig) error
+```
+
+
+
+### func (*USB_DEVICE) DTR
+
+```go
+func (usbdev *USB_DEVICE) DTR() bool
+```
+
+
+
+### func (*USB_DEVICE) RTS
+
+```go
+func (usbdev *USB_DEVICE) RTS() bool
+```
+
+
+
+### func (*USB_DEVICE) ReadByte
+
+```go
+func (usbdev *USB_DEVICE) ReadByte() (byte, error)
+```
+
+
+
+### func (*USB_DEVICE) Write
+
+```go
+func (usbdev *USB_DEVICE) Write(data []byte) (n int, err error)
+```
+
+
+
+### func (*USB_DEVICE) WriteByte
+
+```go
+func (usbdev *USB_DEVICE) WriteByte(c byte) error
+```
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/macropad-rp2040.md b/content/docs/reference/microcontrollers/machine/macropad-rp2040.md
new file mode 100644
index 00000000..ba6f86f4
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/macropad-rp2040.md
@@ -0,0 +1,1692 @@
+
+---
+title: macropad-rp2040
+---
+
+
+## Constants
+
+```go
+const (
+	NeopixelCount	= 12
+
+	// Onboard crystal oscillator frequency, in MHz.
+	xoscFreq	= 12	// MHz
+)
+```
+
+
+
+```go
+const (
+	SWITCH	= GPIO0
+	BUTTON	= GPIO0
+
+	KEY1	= GPIO1
+	KEY2	= GPIO2
+	KEY3	= GPIO3
+	KEY4	= GPIO4
+	KEY5	= GPIO5
+	KEY6	= GPIO6
+	KEY7	= GPIO7
+	KEY8	= GPIO8
+	KEY9	= GPIO9
+	KEY10	= GPIO10
+	KEY11	= GPIO11
+	KEY12	= GPIO12
+
+	LED	= GPIO13
+
+	SPEAKER_ENABLE	= GPIO14
+	SPEAKER		= GPIO16
+
+	ROT_A	= GPIO18
+	ROT_B	= GPIO17
+
+	OLED_CS		= GPIO22
+	OLED_RST	= GPIO23
+	OLED_DC		= GPIO24
+
+	NEOPIXEL	= GPIO19
+	WS2812		= NEOPIXEL
+)
+```
+
+
+
+```go
+const (
+	I2C0_SDA_PIN	= GPIO20
+	I2C0_SCL_PIN	= GPIO21
+
+	I2C1_SDA_PIN	= NoPin	// not pinned out
+	I2C1_SCL_PIN	= NoPin	// not pinned out
+)
+```
+
+I2C Default pins on Raspberry Pico.
+
+
+```go
+const (
+	// Default Serial Clock Bus 1 for SPI communications
+	SPI1_SCK_PIN	= GPIO26
+	// Default Serial Out Bus 1 for SPI communications
+	SPI1_SDO_PIN	= GPIO27	// Tx
+	// Default Serial In Bus 1 for SPI communications
+	SPI1_SDI_PIN	= GPIO28	// Rx
+
+	SPI0_SCK_PIN	= NoPin	// not pinned out
+	SPI0_SDO_PIN	= NoPin	// not pinned out
+	SPI0_SDI_PIN	= NoPin	// not pinned out
+)
+```
+
+SPI default pins
+
+
+```go
+const (
+	UART0_TX_PIN	= GPIO0
+	UART0_RX_PIN	= GPIO1
+	UART_TX_PIN	= UART0_TX_PIN
+	UART_RX_PIN	= UART0_RX_PIN
+)
+```
+
+UART pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	LS_SE0	= 0b00
+	LS_J	= 0b01
+	LS_K	= 0b10
+	LS_SE1	= 0b11
+)
+```
+
+
+
+```go
+const (
+	cpuFreq			= 200 * MHz
+	_NUMBANK0_GPIOS		= 30
+	_NUMBANK0_IRQS		= 4
+	_NUMIRQ			= 32
+	rp2350ExtraReg		= 0
+	RESETS_RESET_Msk	= 0x01ffffff
+	initUnreset		= rp.RESETS_RESET_ADC |
+		rp.RESETS_RESET_RTC |
+		rp.RESETS_RESET_SPI0 |
+		rp.RESETS_RESET_SPI1 |
+		rp.RESETS_RESET_UART0 |
+		rp.RESETS_RESET_UART1 |
+		rp.RESETS_RESET_USBCTRL
+	initDontReset	= rp.RESETS_RESET_IO_QSPI |
+		rp.RESETS_RESET_PADS_QSPI |
+		rp.RESETS_RESET_PLL_USB |
+		rp.RESETS_RESET_USBCTRL |
+		rp.RESETS_RESET_SYSCFG |
+		rp.RESETS_RESET_PLL_SYS
+	padEnableMask	= rp.PADS_BANK0_GPIO0_IE_Msk |
+		rp.PADS_BANK0_GPIO0_OD_Msk
+)
+```
+
+
+
+```go
+const (
+	PinOutput	PinMode	= iota
+	PinInput
+	PinInputPulldown
+	PinInputPullup
+	PinAnalog
+	PinUART
+	PinPWM
+	PinI2C
+	PinSPI
+	PinPIO0
+	PinPIO1
+)
+```
+
+
+
+```go
+const (
+	ADC0	Pin	= GPIO26
+	ADC1	Pin	= GPIO27
+	ADC2	Pin	= GPIO28
+	ADC3	Pin	= GPIO29
+
+	thermADC	= 30
+)
+```
+
+Analog pins on RP2040.
+
+
+```go
+const (
+	// Edge falling
+	PinFalling	PinChange	= 4 << iota
+	// Edge rising
+	PinRising
+
+	PinToggle	= PinFalling | PinRising
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// GPIO pins
+	GPIO0	Pin	= 0	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO1	Pin	= 1	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO2	Pin	= 2	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO3	Pin	= 3	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO4	Pin	= 4	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO5	Pin	= 5	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO6	Pin	= 6	// peripherals: PWM3 channel A, I2C1 SDA
+	GPIO7	Pin	= 7	// peripherals: PWM3 channel B, I2C1 SCL
+	GPIO8	Pin	= 8	// peripherals: PWM4 channel A, I2C0 SDA
+	GPIO9	Pin	= 9	// peripherals: PWM4 channel B, I2C0 SCL
+	GPIO10	Pin	= 10	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO11	Pin	= 11	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO12	Pin	= 12	// peripherals: PWM6 channel A, I2C0 SDA
+	GPIO13	Pin	= 13	// peripherals: PWM6 channel B, I2C0 SCL
+	GPIO14	Pin	= 14	// peripherals: PWM7 channel A, I2C1 SDA
+	GPIO15	Pin	= 15	// peripherals: PWM7 channel B, I2C1 SCL
+	GPIO16	Pin	= 16	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO17	Pin	= 17	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO18	Pin	= 18	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO19	Pin	= 19	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO20	Pin	= 20	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO21	Pin	= 21	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO22	Pin	= 22	// peripherals: PWM3 channel A
+	GPIO23	Pin	= 23	// peripherals: PWM3 channel B
+	GPIO24	Pin	= 24	// peripherals: PWM4 channel A
+	GPIO25	Pin	= 25	// peripherals: PWM4 channel B
+	GPIO26	Pin	= 26	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO27	Pin	= 27	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO28	Pin	= 28	// peripherals: PWM6 channel A
+	GPIO29	Pin	= 29	// peripherals: PWM6 channel B
+)
+```
+
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 8.3s).
+	//
+	// Nominal 1us per watchdog tick, 24-bit counter,
+	// but due to errata two ticks consumed per 1us.
+	// See: Errata RP2040-E1
+	WatchdogMaxTimeout = (rp.WATCHDOG_LOAD_LOAD_Msk / 1000) / 2
+)
+```
+
+
+
+```go
+const XOSC_STARTUP_DELAY_MULTIPLIER = 64
+```
+
+On some boards, the XOSC can take longer than usual to stabilize. On such
+boards, this is needed to avoid a hard fault on boot/reset. Refer to
+PICO_XOSC_STARTUP_DELAY_MULTIPLIER in the Pico SDK for additional details.
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	UART0	= &_UART0
+	_UART0	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART0,
+	}
+
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART1,
+	}
+)
+```
+
+UART on the RP2040
+
+
+```go
+var RTC = (*rtcType)(unsafe.Pointer(rp.RTC))
+```
+
+
+
+```go
+var (
+	ErrRtcDelayTooSmall	= errors.New("RTC interrupt deplay is too small, shall be at least 1 second")
+	ErrRtcDelayTooLarge	= errors.New("RTC interrupt deplay is too large, shall be no more than 1 day")
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	I2C0	= &_I2C0
+	_I2C0	= I2C{
+		Bus: rp.I2C0,
+	}
+	I2C1	= &_I2C1
+	_I2C1	= I2C{
+		Bus: rp.I2C1,
+	}
+)
+```
+
+I2C on the RP2040/RP2350
+
+
+```go
+var (
+	ErrBadPeriod = errors.New("period outside valid range 8ns..268ms")
+)
+```
+
+
+
+```go
+var (
+	PWM0	= getPWMGroup(0)
+	PWM1	= getPWMGroup(1)
+	PWM2	= getPWMGroup(2)
+	PWM3	= getPWMGroup(3)
+	PWM4	= getPWMGroup(4)
+	PWM5	= getPWMGroup(5)
+	PWM6	= getPWMGroup(6)
+	PWM7	= getPWMGroup(7)
+)
+```
+
+Hardware Pulse Width Modulation (PWM) API
+PWM peripherals available on RP2040. Each peripheral has 2 pins available for
+a total of 16 available PWM outputs. Some pins may not be available on some boards.
+
+The RP2040 PWM block has 8 identical slices. Each slice can drive two PWM output signals, or
+measure the frequency or duty cycle of an input signal. This gives a total of up to 16 controllable
+PWM outputs. All 30 GPIOs can be driven by the PWM block
+
+The PWM hardware functions by continuously comparing the input value to a free-running counter. This produces a
+toggling output where the amount of time spent at the high output level is proportional to the input value. The fraction of
+time spent at the high signal level is known as the duty cycle of the signal.
+
+The default behaviour of a PWM slice is to count upward until the wrap value (\ref pwm_config_set_wrap) is reached, and then
+immediately wrap to 0. PWM slices also offer a phase-correct mode, where the counter starts to count downward after
+reaching TOP, until it reaches 0 again.
+
+
+```go
+var (
+	SPI0	= &SPI{
+		Bus: rp.SPI0,
+	}
+	SPI1	= &SPI{
+		Bus: rp.SPI1,
+	}
+)
+```
+
+SPI on the RP2040
+
+
+```go
+var (
+	ErrLSBNotSupported	= errors.New("SPI LSB unsupported on PL022")
+	ErrSPITimeout		= errors.New("SPI timeout")
+	ErrSPIBaud		= errors.New("SPI baud too low or above 66.5Mhz")
+	errSPIInvalidSDI	= errors.New("invalid SPI SDI pin")
+	errSPIInvalidSDO	= errors.New("invalid SPI SDO pin")
+	errSPIInvalidSCK	= errors.New("invalid SPI SCK pin")
+)
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the RP2040.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ChipVersion
+
+```go
+func ChipVersion() uint8
+```
+
+ChipVersion returns the version of the chip. 1 is returned for B0 and B1
+chip.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func CurrentCore
+
+```go
+func CurrentCore() int
+```
+
+CurrentCore returns the core number the call was made from.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of semi-random data based on ring oscillator.
+
+Unlike some other implementations of GetRNG, these random numbers are not
+cryptographically secure and must not be used for cryptographic operations
+(nonces, etc).
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC resets the ADC peripheral.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func NumCores
+
+```go
+func NumCores() int
+```
+
+NumCores returns number of cores available on the device.
+
+
+### func PWMPeripheral
+
+```go
+func PWMPeripheral(pin Pin) (sliceNum uint8, err error)
+```
+
+Peripheral returns the RP2040 PWM peripheral which ranges from 0 to 7. Each
+PWM peripheral has 2 channels, A and B which correspond to 0 and 1 in the program.
+This number corresponds to the package's PWM0 throughout PWM7 handles
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() (millicelsius int32)
+```
+
+ReadTemperature does a one-shot sample of the internal temperature sensor and returns a milli-celsius reading.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig) error
+```
+
+Configure sets the ADC pin to analog input mode.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns a one-shot ADC sample reading.
+
+
+### func (ADC) GetADCChannel
+
+```go
+func (a ADC) GetADCChannel() (c ADCChannel, err error)
+```
+
+GetADCChannel returns the channel associated with the ADC pin.
+
+
+
+
+## type ADCChannel
+
+```go
+type ADCChannel uint8
+```
+
+ADCChannel is the ADC peripheral mux channel. 0-4.
+
+
+
+### func (ADCChannel) Configure
+
+```go
+func (c ADCChannel) Configure(config ADCConfig) error
+```
+
+Configure sets the channel's associated pin to analog input mode.
+The powered on temperature sensor increases ADC_AVDD current by approximately 40 μA.
+
+
+### func (ADCChannel) Pin
+
+```go
+func (c ADCChannel) Pin() (p Pin, err error)
+```
+
+The Pin method returns the GPIO Pin associated with the ADC mux channel, if it has one.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*rp.I2C0_Type
+	mode		I2CMode
+	txInProgress	bool
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure initializes i2c peripheral and configures I2C config's pins passed.
+Here's a list of valid SDA and SCL GPIO pins on bus I2C0 of the rp2040:
+
+	SDA: 0, 4, 8, 12, 16, 20
+	SCL: 1, 5, 9, 13, 17, 21
+
+Same as above for I2C1 bus:
+
+	SDA: 2, 6, 10, 14, 18, 26
+	SCL: 3, 7, 11, 15, 19, 27
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint16) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx performs a write and then a read transfer placing the result in
+in r.
+
+Passing a nil value for w or r skips the transfer corresponding to write
+or read, respectively.
+
+	i2c.Tx(addr, nil, r)
+
+Performs only a read transfer.
+
+	i2c.Tx(addr, w, nil)
+
+Performs only a write transfer.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	// SDA/SCL Serial Data and clock pins. Refer to datasheet to see
+	// which pins match the desired bus.
+	SDA, SCL	Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure configures the gpio pin as per mode.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get reads the pin value.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set drives the pin high if value is true else drives it low.
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+PinChange represents one or more trigger events that can happen on a given GPIO pin
+on the RP2040. ORed PinChanges are valid input to most IRQ functions.
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus *rp.SPI0_Type
+}
+```
+
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup/initialize the SPI interface.
+Default baudrate of 4MHz is used if Frequency == 0. Default
+word length (data bits) is 8.
+Below is a list of GPIO pins corresponding to SPI0 bus on the rp2040:
+
+	SI : 0, 4, 17  a.k.a RX and MISO (if rp2040 is master)
+	SO : 3, 7, 19  a.k.a TX and MOSI (if rp2040 is master)
+	SCK: 2, 6, 18
+
+SPI1 bus GPIO pins:
+
+	SI : 8, 12
+	SO : 11, 15
+	SCK: 10, 14
+
+No pin configuration is needed of SCK, SDO and SDI needed after calling Configure.
+
+
+### func (*SPI) GetBaudRate
+
+```go
+func (spi *SPI) GetBaudRate() uint32
+```
+
+
+
+### func (*SPI) PrintRegs
+
+```go
+func (spi *SPI) PrintRegs()
+```
+
+PrintRegs prints SPI's peripheral common registries current values
+
+
+### func (*SPI) SetBaudRate
+
+```go
+func (spi *SPI) SetBaudRate(br uint32) error
+```
+
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Write a single byte and read a single byte from TX/RX FIFO.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) (err error)
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+Remark: This implementation (RP2040) allows reading into buffer with a custom repeated
+value on tx.
+
+	spi.Tx([]byte{0xff}, rx) // may cause unwanted heap allocations.
+
+This form sends 0xff and puts the result into rx buffer. Useful for reading from SD cards
+which require 0xff input on SI.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	// LSB not supported on rp2040.
+	LSBFirst	bool
+	// Mode's two most LSB are CPOL and CPHA. i.e. Mode==2 (0b10) is CPOL=1, CPHA=0
+	Mode	uint8
+	// Serial clock pin
+	SCK	Pin
+	// TX or Serial Data Out (MOSI if rp2040 is master)
+	SDO	Pin
+	// RX or Serial Data In (MISO if rp2040 is master)
+	SDI	Pin
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*rp.UART0_Type
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the RP2040.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the baudrate to be used for the UART.
+
+
+### func (*UART) SetFormat
+
+```go
+func (uart *UART) SetFormat(databits, stopbits uint8, parity UARTParity) error
+```
+
+SetFormat for number of data bits, stop bits, and parity for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) ClearStallEPIn
+
+```go
+func (dev *USBDevice) ClearStallEPIn(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB IN endpoint.
+
+
+### func (*USBDevice) ClearStallEPOut
+
+```go
+func (dev *USBDevice) ClearStallEPOut(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB OUT endpoint.
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+### func (*USBDevice) SetStallEPIn
+
+```go
+func (dev *USBDevice) SetStallEPIn(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB IN endpoint.
+
+
+### func (*USBDevice) SetStallEPOut
+
+```go
+func (dev *USBDevice) SetStallEPOut(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB OUT endpoint.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/microcontrollers/machine/maixbit.md b/content/docs/reference/microcontrollers/machine/maixbit.md
similarity index 78%
rename from content/microcontrollers/machine/maixbit.md
rename to content/docs/reference/microcontrollers/machine/maixbit.md
index 3e087894..bb1c56a5 100644
--- a/content/microcontrollers/machine/maixbit.md
+++ b/content/docs/reference/microcontrollers/machine/maixbit.md
@@ -425,6 +425,61 @@ const (
 
 TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
 
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
 
 ```go
 const NoPin = Pin(0xff)
@@ -437,8 +492,8 @@ of the pins in a peripheral unconfigured (if supported by the hardware).
 ```go
 const (
 	PinInput	PinMode	= iota
-	PinInputPullUp
-	PinInputPullDown
+	PinInputPullup
+	PinInputPulldown
 	PinOutput
 )
 ```
@@ -446,6 +501,16 @@ const (
 Pin modes.
 
 
+```go
+const (
+	PinInputPullUp		= PinInputPullup
+	PinInputPullDown	= PinInputPulldown
+)
+```
+
+Deprecated: use PinInputPullup and PinInputPulldown instead.
+
+
 ```go
 const (
 	PinRising	PinChange	= 1 << iota
@@ -469,44 +534,54 @@ const (
 SPI phase and polarity configs CPOL and CPHA
 
 
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
 
 
 
 ## Variables
 
 ```go
-var (
-	SPI0	= SPI{
-		Bus: kendryte.SPI0,
-	}
-	SPI1	= SPI{
-		Bus: kendryte.SPI1,
-	}
-)
+var DefaultUART = UART0
 ```
 
-SPI on the MAix Bit.
 
 
 ```go
 var (
-	I2C0	= I2C{
-		Bus: kendryte.I2C0,
-	}
-	I2C1	= I2C{
-		Bus: kendryte.I2C1,
+	SPI0	= &SPI{
+		Bus: kendryte.SPI0,
 	}
-	I2C2	= I2C{
-		Bus: kendryte.I2C2,
+	SPI1	= &SPI{
+		Bus: kendryte.SPI1,
 	}
 )
 ```
 
-I2C on the MAix Bit.
+SPI on the MAix Bit.
 
 
 ```go
 var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
 	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
 	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
 	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
@@ -519,15 +594,42 @@ var (
 
 ```go
 var (
-	UART0 = UART{Bus: kendryte.UARTHS, Buffer: NewRingBuffer()}
+	UART0	= &_UART0
+	_UART0	= UART{Bus: kendryte.UARTHS, Buffer: NewRingBuffer()}
+)
+```
+
+
+
+```go
+var (
+	I2C0	= (*I2C)(unsafe.Pointer(kendryte.I2C0))
+	I2C1	= (*I2C)(unsafe.Pointer(kendryte.I2C1))
+	I2C2	= (*I2C)(unsafe.Pointer(kendryte.I2C2))
+)
+```
+
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
 )
 ```
 
 
 
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
 ```go
 var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
 )
 ```
 
@@ -544,6 +646,14 @@ func CPUFrequency() uint32
 
 
 
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
 ### func NewRingBuffer
 
 ```go
@@ -568,6 +678,24 @@ type ADC struct {
 
 
 
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
 ## type FPIOAFunction
 
 ```go
@@ -583,7 +711,7 @@ type FPIOAFunction uint8
 
 ```go
 type I2C struct {
-	Bus *kendryte.I2C_Type
+	Bus kendryte.I2C_Type
 }
 ```
 
@@ -591,19 +719,19 @@ I2C on the K210.
 
 
 
-### func (I2C) Configure
+### func (*I2C) Configure
 
 ```go
-func (i2c I2C) Configure(config I2CConfig) error
+func (i2c *I2C) Configure(config I2CConfig) error
 ```
 
 Configure is intended to setup the I2C interface.
 
 
-### func (I2C) ReadRegister
+### func (*I2C) ReadRegister
 
 ```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
 ```
 
 ReadRegister transmits the register, restarts the connection as a read
@@ -614,10 +742,19 @@ is a shortcut to easily read such registers. Also, it only works for devices
 with 7-bit addresses, which is the vast majority.
 
 
-### func (I2C) Tx
+### func (*I2C) SetBaudRate
 
 ```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
 ```
 
 Tx does a single I2C transaction at the specified address.
@@ -625,10 +762,10 @@ It clocks out the given address, writes the bytes in w, reads back len(r)
 bytes and stores them in r, and generates a stop condition on the bus.
 
 
-### func (I2C) WriteRegister
+### func (*I2C) WriteRegister
 
 ```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
 ```
 
 WriteRegister transmits first the register and then the data to the
@@ -657,14 +794,124 @@ I2CConfig is used to store config info for I2C.
 
 
 
-## type PWM
+## type I2CMode
 
 ```go
-type PWM struct {
-	Pin Pin
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
 }
 ```
 
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
 
 
 
@@ -799,6 +1046,9 @@ type PinConfig struct {
 type PinMode uint8
 ```
 
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
 
 
 
@@ -870,10 +1120,10 @@ type SPI struct {
 
 
 
-### func (SPI) Configure
+### func (*SPI) Configure
 
 ```go
-func (spi SPI) Configure(config SPIConfig) error
+func (spi *SPI) Configure(config SPIConfig) error
 ```
 
 Configure is intended to setup the SPI interface.
@@ -881,38 +1131,38 @@ Only SPI controller 0 and 1 can be used because SPI2 is a special
 peripheral-mode controller and SPI3 is used for flashing.
 
 
-### func (SPI) Transfer
+### func (*SPI) Transfer
 
 ```go
-func (spi SPI) Transfer(w byte) (byte, error)
+func (spi *SPI) Transfer(w byte) (byte, error)
 ```
 
 Transfer writes/reads a single byte using the SPI interface.
 
 
-### func (SPI) Tx
+### func (*SPI) Tx
 
 ```go
-func (spi SPI) Tx(w, r []byte) error
+func (spi *SPI) Tx(w, r []byte) error
 ```
 
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
 interface, there must always be the same number of bytes written as bytes read.
 The Tx method knows about this, and offers a few different ways of calling it.
 
 This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
 Note that the tx and rx buffers must be the same size:
 
-		spi.Tx(tx, rx)
+	spi.Tx(tx, rx)
 
 This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
 until all the bytes in the command packet have been received:
 
-		spi.Tx(tx, nil)
+	spi.Tx(tx, nil)
 
 This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
 
-		spi.Tx(nil, rx)
+	spi.Tx(nil, rx)
 
 
 
@@ -948,67 +1198,70 @@ type UART struct {
 
 
 
-### func (UART) Buffered
+### func (*UART) Buffered
 
 ```go
-func (uart UART) Buffered() int
+func (uart *UART) Buffered() int
 ```
 
 Buffered returns the number of bytes currently stored in the RX buffer.
 
 
-### func (UART) Configure
+### func (*UART) Configure
 
 ```go
-func (uart UART) Configure(config UARTConfig)
+func (uart *UART) Configure(config UARTConfig)
 ```
 
 
 
-### func (UART) Read
+### func (*UART) Read
 
 ```go
-func (uart UART) Read(data []byte) (n int, err error)
+func (uart *UART) Read(data []byte) (n int, err error)
 ```
 
 Read from the RX buffer.
 
 
-### func (UART) ReadByte
+### func (*UART) ReadByte
 
 ```go
-func (uart UART) ReadByte() (byte, error)
+func (uart *UART) ReadByte() (byte, error)
 ```
 
 ReadByte reads a single byte from the RX buffer.
 If there is no data in the buffer, returns an error.
 
 
-### func (UART) Receive
+### func (*UART) Receive
 
 ```go
-func (uart UART) Receive(data byte)
+func (uart *UART) Receive(data byte)
 ```
 
 Receive handles adding data to the UART's data buffer.
 Usually called by the IRQ handler for a machine.
 
 
-### func (UART) Write
+### func (*UART) Write
 
 ```go
-func (uart UART) Write(data []byte) (n int, err error)
+func (uart *UART) Write(data []byte) (n int, err error)
 ```
 
-Write data to the UART.
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
 
 
-### func (UART) WriteByte
+### func (*UART) WriteByte
 
 ```go
-func (uart UART) WriteByte(c byte)
+func (uart *UART) WriteByte(c byte) error
 ```
 
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
 
 
 
@@ -1020,9 +1273,26 @@ type UARTConfig struct {
 	BaudRate	uint32
 	TX		Pin
 	RX		Pin
+	RTS		Pin
+	CTS		Pin
 }
 ```
 
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
 
 
 
diff --git a/content/docs/reference/microcontrollers/machine/matrixportal-m4.md b/content/docs/reference/microcontrollers/machine/matrixportal-m4.md
new file mode 100644
index 00000000..c84284c2
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/matrixportal-m4.md
@@ -0,0 +1,1782 @@
+
+---
+title: matrixportal-m4
+---
+
+
+## Constants
+
+```go
+const (
+	//    Pin   // Function          SERCOM  PWM  Interrupt
+	//    ----  // ----------------  ------  ---  ---------
+	D0	= PA01	// UART RX            1[1]   PWM  EXTI1
+	D1	= PA00	// UART TX            1[0]   PWM  EXTI0
+	D2	= PB22	// Button "Up"                    EXTI6
+	D3	= PB23	// Button "Down"                  EXTI7
+	D4	= PA23	// NeoPixel                       EXTI7
+	D5	= PB31	// I2C SDA            5[1]        EXTI15
+	D6	= PB30	// I2C SCL            5[0]        EXTI14
+	D7	= PB00	// HUB75 R1                       EXTI0
+	D8	= PB01	// HUB75 G1                       EXTI1
+	D9	= PB02	// HUB75 B1                       EXTI2
+	D10	= PB03	// HUB75 R2                       EXTI3
+	D11	= PB04	// HUB75 G2                       EXTI4
+	D12	= PB05	// HUB75 B2                       EXTI5
+	D13	= PA14	// LED                       PWM  EXTI14
+	D14	= PB06	// HUB75 CLK                      EXTI6
+	D15	= PB14	// HUB75 LAT                      EXTI14
+	D16	= PB12	// HUB75 OE                       EXTI12
+	D17	= PB07	// HUB75 ADDR A                   EXTI7
+	D18	= PB08	// HUB75 ADDR B                   EXTI8
+	D19	= PB09	// HUB75 ADDR C                   EXTI9
+	D20	= PB15	// HUB75 ADDR D                   EXTI15
+	D21	= PB13	// HUB75 ADDR E                   EXTI13
+	D22	= PA02	// ADC (A0)                       EXTI2
+	D23	= PA05	// ADC (A1)                       EXTI5
+	D24	= PA04	// ADC (A2)                  PWM  EXTI4
+	D25	= PA06	// ADC (A3)                  PWM  EXTI6
+	D26	= PA07	// ADC (A4)                       EXTI7
+	D27	= PA12	// ESP32 UART RX      4[1]   PWM  EXTI12
+	D28	= PA13	// ESP32 UART TX      4[0]   PWM  EXTI13
+	D29	= PA20	// ESP32 GPIO0               PWM  EXTI4
+	D30	= PA21	// ESP32 Reset               PWM  EXTI5
+	D31	= PA22	// ESP32 Busy                PWM  EXTI6
+	D32	= PA18	// ESP32 RTS                 PWM  EXTI2
+	D33	= PB17	// ESP32 SPI CS              PWM  EXTI1
+	D34	= PA16	// ESP32 SPI SCK      3[1]   PWM  EXTI0
+	D35	= PA17	// ESP32 SPI SDI      3[0]   PWM  EXTI1
+	D36	= PA19	// ESP32 SPI SDO      1[3]   PWM  EXTI3
+	D37	= NoPin	// USB Host enable
+	D38	= PA24	// USB DM
+	D39	= PA25	// USB DP
+	D40	= PA03	// DAC/VREFP
+	D41	= PB10	// Flash QSPI SCK
+	D42	= PB11	// Flash QSPI CS
+	D43	= PA08	// Flash QSPI I00
+	D44	= PA09	// Flash QSPI IO1
+	D45	= PA10	// Flash QSPI IO2
+	D46	= PA11	// Flash QSPI IO3
+	D47	= PA27	// LIS3DH IRQ                     EXTI11
+	D48	= PA05	// SPI SCK            0[1]        EXTI5
+	D49	= PA04	// SPI SDO            0[0]   PWM  EXTI4
+	D50	= PA07	// SPI SDI            0[3]        EXTI7
+)
+```
+
+Digital pins
+
+
+```go
+const (
+	A0	= PA02	// ADC Channel 0
+	A1	= PA05	// ADC Channel 5
+	A2	= PA04	// ADC Channel 4
+	A3	= PA06	// ADC Channel 6
+	A4	= PA07	// ADC Channel 7
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	LED		= D13
+	NEOPIXEL	= D4
+	WS2812		= D4
+)
+```
+
+LED pins
+
+
+```go
+const (
+	BUTTON_UP	= D2
+	BUTTON_DOWN	= D3
+)
+```
+
+Button pins
+
+
+```go
+const (
+	UART1_RX_PIN	= D0	// SERCOM1[1]
+	UART1_TX_PIN	= D1	// SERCOM1[0]
+
+	UART2_RX_PIN	= D27	// SERCOM4[1] (ESP32 RX)
+	UART2_TX_PIN	= D28	// SERCOM4[0] (ESP32 TX)
+
+	UART_RX_PIN	= UART1_RX_PIN
+	UART_TX_PIN	= UART1_TX_PIN
+)
+```
+
+UART pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= D34	// SERCOM3[1] (ESP32 SCK)
+	SPI0_SDO_PIN	= D36	// SERCOM1[3] (ESP32 SDO)
+	SPI0_SDI_PIN	= D35	// SERCOM3[0] (ESP32 SDI)
+
+	SPI1_SCK_PIN	= D48	// SERCOM0[1]
+	SPI1_SDO_PIN	= D49	// SERCOM0[0]
+	SPI1_SDI_PIN	= D50	// SERCOM0[3]
+
+	SPI_SCK_PIN	= SPI0_SCK_PIN
+	SPI_SDO_PIN	= SPI0_SDO_PIN
+	SPI_SDI_PIN	= SPI0_SDI_PIN
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	I2C0_SDA_PIN	= D5	// SERCOM5[1]
+	I2C0_SCL_PIN	= D6	// SERCOM5[0]
+
+	I2C_SDA_PIN	= I2C0_SDA_PIN
+	I2C_SCL_PIN	= I2C0_SCL_PIN
+
+	SDA_PIN	= I2C_SDA_PIN	// awkward naming required by machine_atsamd51.go
+	SCL_PIN	= I2C_SCL_PIN	//
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	NINA_ACK	= D31
+	NINA_GPIO0	= D29
+	NINA_RESETN	= D30
+
+	NINA_RX		= UART2_RX_PIN
+	NINA_TX		= UART2_TX_PIN
+	NINA_RTS	= D32
+
+	NINA_CS		= D33
+	NINA_SDO	= SPI0_SDO_PIN
+	NINA_SDI	= SPI0_SDI_PIN
+	NINA_SCK	= SPI0_SCK_PIN
+)
+```
+
+ESP32 pins
+
+
+```go
+const (
+	HUB75_R1	= D7
+	HUB75_G1	= D8
+	HUB75_B1	= D9
+	HUB75_R2	= D10
+	HUB75_G2	= D11
+	HUB75_B2	= D12
+
+	HUB75_CLK	= D14
+	HUB75_LAT	= D15
+	HUB75_OE	= D16
+	HUB75_ADDR_A	= D17
+	HUB75_ADDR_B	= D18
+	HUB75_ADDR_C	= D19
+	HUB75_ADDR_D	= D20
+	HUB75_ADDR_E	= D21
+)
+```
+
+HUB75 pins
+
+
+```go
+const (
+	USBCDC_DM_PIN	= D38
+	USBCDC_DP_PIN	= D39
+
+	UART0_RX_PIN	= USBCDC_DM_PIN
+	UART0_TX_PIN	= USBCDC_DP_PIN
+)
+```
+
+USB CDC pins (UART0)
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinAnalog		PinMode	= 1
+	PinSERCOM		PinMode	= 2
+	PinSERCOMAlt		PinMode	= 3
+	PinTimer		PinMode	= 4
+	PinTimerAlt		PinMode	= 5
+	PinTCCPDEC		PinMode	= 6
+	PinCom			PinMode	= 7
+	PinSDHC			PinMode	= 8
+	PinI2S			PinMode	= 9
+	PinPCC			PinMode	= 10
+	PinGMAC			PinMode	= 11
+	PinACCLK		PinMode	= 12
+	PinCCL			PinMode	= 13
+	PinDigital		PinMode	= 14
+	PinInput		PinMode	= 15
+	PinInputPullup		PinMode	= 16
+	PinOutput		PinMode	= 17
+	PinTCCE			PinMode	= PinTimer
+	PinTCCF			PinMode	= PinTimerAlt
+	PinTCCG			PinMode	= PinTCCPDEC
+	PinInputPulldown	PinMode	= 18
+	PinCAN			PinMode	= 19
+	PinCAN0			PinMode	= PinSDHC
+	PinCAN1			PinMode	= PinCom
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
+	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
+	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	PA00	Pin	= 0
+	PA01	Pin	= 1
+	PA02	Pin	= 2
+	PA03	Pin	= 3
+	PA04	Pin	= 4
+	PA05	Pin	= 5
+	PA06	Pin	= 6
+	PA07	Pin	= 7
+	PA08	Pin	= 8	// peripherals: TCC0 channel 0, TCC1 channel 4, sercomI2CM0 SDA, sercomI2CM2 SDA
+	PA09	Pin	= 9	// peripherals: TCC0 channel 1, TCC1 channel 5, sercomI2CM0 SCL, sercomI2CM2 SCL
+	PA10	Pin	= 10	// peripherals: TCC0 channel 2, TCC1 channel 6
+	PA11	Pin	= 11	// peripherals: TCC0 channel 3, TCC1 channel 7
+	PA12	Pin	= 12	// peripherals: TCC0 channel 6, TCC1 channel 2, sercomI2CM2 SDA, sercomI2CM4 SDA
+	PA13	Pin	= 13	// peripherals: TCC0 channel 7, TCC1 channel 3, sercomI2CM2 SCL, sercomI2CM4 SCL
+	PA14	Pin	= 14	// peripherals: TCC2 channel 0, TCC1 channel 2
+	PA15	Pin	= 15	// peripherals: TCC2 channel 1, TCC1 channel 3
+	PA16	Pin	= 16	// peripherals: TCC1 channel 0, TCC0 channel 4, sercomI2CM1 SDA, sercomI2CM3 SDA
+	PA17	Pin	= 17	// peripherals: TCC1 channel 1, TCC0 channel 5, sercomI2CM1 SCL, sercomI2CM3 SCL
+	PA18	Pin	= 18	// peripherals: TCC1 channel 2, TCC0 channel 6
+	PA19	Pin	= 19	// peripherals: TCC1 channel 3, TCC0 channel 7
+	PA20	Pin	= 20	// peripherals: TCC1 channel 4, TCC0 channel 0
+	PA21	Pin	= 21	// peripherals: TCC1 channel 5, TCC0 channel 1
+	PA22	Pin	= 22	// peripherals: TCC1 channel 6, TCC0 channel 2, sercomI2CM3 SDA, sercomI2CM5 SDA
+	PA23	Pin	= 23	// peripherals: TCC1 channel 7, TCC0 channel 3, sercomI2CM3 SCL, sercomI2CM5 SCL
+	PA24	Pin	= 24	// peripherals: TCC2 channel 2
+	PA25	Pin	= 25	// peripherals: TCC2 channel 3
+	PA26	Pin	= 26
+	PA27	Pin	= 27
+	PA28	Pin	= 28
+	PA29	Pin	= 29
+	PA30	Pin	= 30	// peripherals: TCC2 channel 0
+	PA31	Pin	= 31	// peripherals: TCC2 channel 1
+	PB00	Pin	= 32
+	PB01	Pin	= 33
+	PB02	Pin	= 34	// peripherals: TCC2 channel 2
+	PB03	Pin	= 35	// peripherals: TCC2 channel 3
+	PB04	Pin	= 36
+	PB05	Pin	= 37
+	PB06	Pin	= 38
+	PB07	Pin	= 39
+	PB08	Pin	= 40
+	PB09	Pin	= 41
+	PB10	Pin	= 42	// peripherals: TCC0 channel 4, TCC1 channel 0
+	PB11	Pin	= 43	// peripherals: TCC0 channel 5, TCC1 channel 1
+	PB12	Pin	= 44	// peripherals: TCC3 channel 0, TCC0 channel 0
+	PB13	Pin	= 45	// peripherals: TCC3 channel 1, TCC0 channel 1
+	PB14	Pin	= 46	// peripherals: TCC4 channel 0, TCC0 channel 2
+	PB15	Pin	= 47	// peripherals: TCC4 channel 1, TCC0 channel 3
+	PB16	Pin	= 48	// peripherals: TCC3 channel 0, TCC0 channel 4
+	PB17	Pin	= 49	// peripherals: TCC3 channel 1, TCC0 channel 5
+	PB18	Pin	= 50	// peripherals: TCC1 channel 0
+	PB19	Pin	= 51	// peripherals: TCC1 channel 1
+	PB20	Pin	= 52	// peripherals: TCC1 channel 2
+	PB21	Pin	= 53	// peripherals: TCC1 channel 3
+	PB22	Pin	= 54
+	PB23	Pin	= 55
+	PB24	Pin	= 56
+	PB25	Pin	= 57
+	PB26	Pin	= 58	// peripherals: TCC1 channel 2
+	PB27	Pin	= 59	// peripherals: TCC1 channel 3
+	PB28	Pin	= 60	// peripherals: TCC1 channel 4
+	PB29	Pin	= 61	// peripherals: TCC1 channel 5
+	PB30	Pin	= 62	// peripherals: TCC4 channel 0, TCC0 channel 6
+	PB31	Pin	= 63	// peripherals: TCC4 channel 1, TCC0 channel 7
+	PC00	Pin	= 64
+	PC01	Pin	= 65
+	PC02	Pin	= 66
+	PC03	Pin	= 67
+	PC04	Pin	= 68	// peripherals: TCC0 channel 0
+	PC05	Pin	= 69	// peripherals: TCC0 channel 1
+	PC06	Pin	= 70
+	PC07	Pin	= 71
+	PC08	Pin	= 72
+	PC09	Pin	= 73
+	PC10	Pin	= 74	// peripherals: TCC0 channel 0, TCC1 channel 4
+	PC11	Pin	= 75	// peripherals: TCC0 channel 1, TCC1 channel 5
+	PC12	Pin	= 76	// peripherals: TCC0 channel 2, TCC1 channel 6
+	PC13	Pin	= 77	// peripherals: TCC0 channel 3, TCC1 channel 7
+	PC14	Pin	= 78	// peripherals: TCC0 channel 4, TCC1 channel 0
+	PC15	Pin	= 79	// peripherals: TCC0 channel 5, TCC1 channel 1
+	PC16	Pin	= 80	// peripherals: TCC0 channel 0
+	PC17	Pin	= 81	// peripherals: TCC0 channel 1
+	PC18	Pin	= 82	// peripherals: TCC0 channel 2
+	PC19	Pin	= 83	// peripherals: TCC0 channel 3
+	PC20	Pin	= 84	// peripherals: TCC0 channel 4
+	PC21	Pin	= 85	// peripherals: TCC0 channel 5
+	PC22	Pin	= 86	// peripherals: TCC0 channel 6
+	PC23	Pin	= 87	// peripherals: TCC0 channel 7
+	PC24	Pin	= 88
+	PC25	Pin	= 89
+	PC26	Pin	= 90
+	PC27	Pin	= 91
+	PC28	Pin	= 92
+	PC29	Pin	= 93
+	PC30	Pin	= 94
+	PC31	Pin	= 95
+	PD00	Pin	= 96
+	PD01	Pin	= 97
+	PD02	Pin	= 98
+	PD03	Pin	= 99
+	PD04	Pin	= 100
+	PD05	Pin	= 101
+	PD06	Pin	= 102
+	PD07	Pin	= 103
+	PD08	Pin	= 104	// peripherals: TCC0 channel 1, sercomI2CM6 SDA, sercomI2CM7 SDA
+	PD09	Pin	= 105	// peripherals: TCC0 channel 2, sercomI2CM6 SCL, sercomI2CM7 SCL
+	PD10	Pin	= 106	// peripherals: TCC0 channel 3
+	PD11	Pin	= 107	// peripherals: TCC0 channel 4
+	PD12	Pin	= 108	// peripherals: TCC0 channel 5
+	PD13	Pin	= 109	// peripherals: TCC0 channel 6
+	PD14	Pin	= 110
+	PD15	Pin	= 111
+	PD16	Pin	= 112
+	PD17	Pin	= 113
+	PD18	Pin	= 114
+	PD19	Pin	= 115
+	PD20	Pin	= 116	// peripherals: TCC1 channel 0
+	PD21	Pin	= 117	// peripherals: TCC1 channel 1
+	PD22	Pin	= 118
+	PD23	Pin	= 119
+	PD24	Pin	= 120
+	PD25	Pin	= 121
+	PD26	Pin	= 122
+	PD27	Pin	= 123
+	PD28	Pin	= 124
+	PD29	Pin	= 125
+	PD30	Pin	= 126
+	PD31	Pin	= 127
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	// SERCOM_FREQ_REF is always reference frequency on SAMD51 regardless of CPU speed.
+	SERCOM_FREQ_REF		= 48000000
+	SERCOM_FREQ_REF_GCLK0	= 120000000
+
+	// Default rise time in nanoseconds, based on 4.7K ohm pull up resistors
+	riseTimeNanoseconds	= 125
+
+	// wire bus states
+	wireUnknownState	= 0
+	wireIdleState		= 1
+	wireOwnerState		= 2
+	wireBusyState		= 3
+
+	// wire commands
+	wireCmdNoAction		= 0
+	wireCmdRepeatStart	= 1
+	wireCmdRead		= 2
+	wireCmdStop		= 3
+)
+```
+
+
+
+```go
+const (
+	QSPI_SCK	= PB10
+	QSPI_CS		= PB11
+	QSPI_DATA0	= PA08
+	QSPI_DATA1	= PA09
+	QSPI_DATA2	= PA10
+	QSPI_DATA3	= PA11
+)
+```
+
+The QSPI peripheral on ATSAMD51 is only available on the following pins
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (16s)
+	WatchdogMaxTimeout = (16384 * 1000) / 1024	// CYC16384/1024kHz
+)
+```
+
+
+
+```go
+const (
+	// these are SAMD51 specific.
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Pos	= 0
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Mask	= 0x3FFF
+
+	usb_DEVICE_PCKSIZE_SIZE_Pos	= 28
+	usb_DEVICE_PCKSIZE_SIZE_Mask	= 0x7
+
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Pos	= 14
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Mask	= 0x3FFF
+
+	NumberOfUSBEndpoints	= 8
+)
+```
+
+
+
+```go
+const HSRAM_SIZE = 0x00030000
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	UART1	= &sercomUSART1
+	UART2	= &sercomUSART4
+
+	DefaultUART	= UART1
+)
+```
+
+UART on the MatrixPortal M4
+
+
+```go
+var (
+	I2C0 = sercomI2CM5
+)
+```
+
+I2C on the MatrixPortal M4
+
+
+```go
+var (
+	SPI0		= sercomSPIM3	// BUG: SDO on SERCOM1!
+	NINA_SPI	= SPI0
+
+	SPI1	= sercomSPIM0
+)
+```
+
+SPI on the MatrixPortal M4
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	DAC0	= DAC{Channel: 0}
+	DAC1	= DAC{Channel: 1}
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the SAMD51.
+
+
+```go
+var (
+	TCC0	= (*TCC)(sam.TCC0)
+	TCC1	= (*TCC)(sam.TCC1)
+	TCC2	= (*TCC)(sam.TCC2)
+	TCC3	= (*TCC)(sam.TCC3)
+	TCC4	= (*TCC)(sam.TCC4)
+)
+```
+
+This chip has five TCC peripherals, which have PWM as one feature.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) and 16 bytes (128 bits) are common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of cryptographically secure random data
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig)
+```
+
+Configure configures a ADCPin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type DAC
+
+```go
+type DAC struct {
+	Channel uint8
+}
+```
+
+DAC on the SAMD51.
+
+
+
+### func (DAC) Configure
+
+```go
+func (dac DAC) Configure(config DACConfig)
+```
+
+Configure the DAC.
+output pin must already be configured.
+
+
+### func (DAC) Set
+
+```go
+func (dac DAC) Set(value uint16) error
+```
+
+Set writes a single 16-bit value to the DAC.
+Since the ATSAMD51 only has a 12-bit DAC, the passed-in value will be scaled down.
+
+
+
+
+## type DACConfig
+
+```go
+type DACConfig struct {
+}
+```
+
+DACConfig placeholder for future expansion.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*sam.SERCOM_I2CM_Type
+	SERCOM	uint8
+}
+```
+
+I2C on the SAMD51.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteByte
+
+```go
+func (i2c *I2C) WriteByte(data byte) error
+```
+
+WriteByte writes a single byte to the I2C bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when configured as an input or as
+an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+### func (Pin) Toggle
+
+```go
+func (p Pin) Toggle()
+```
+
+Toggle switches an output pin from low to high or from high to low.
+Warning: only use this on an output pin!
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*sam.SERCOM_SPIM_Type
+	SERCOM	uint8
+}
+```
+
+SPI
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type TCC
+
+```go
+type TCC sam.TCC_Type
+```
+
+TCC is one timer peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this timer peripheral at
+once.
+
+
+
+### func (*TCC) Channel
+
+```go
+func (tcc *TCC) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin. Note that one channel may be
+shared between multiple pins, and so will have the same duty cycle. If this
+is not desirable, look for a different TCC or consider using a different pin.
+
+
+### func (*TCC) Configure
+
+```go
+func (tcc *TCC) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this TCC.
+
+
+### func (*TCC) Counter
+
+```go
+func (tcc *TCC) Counter() uint32
+```
+
+Counter returns the current counter value of the timer in this TCC
+peripheral. It may be useful for debugging.
+
+
+### func (*TCC) Set
+
+```go
+func (tcc *TCC) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle, in other words the fraction of time the channel output is high (or low
+when inverted). For example, to set it to a 25% duty cycle, use:
+
+	tcc.Set(channel, tcc.Top() / 4)
+
+tcc.Set(channel, 0) will set the output to low and tcc.Set(channel,
+tcc.Top()) will set the output to high, assuming the output isn't inverted.
+
+
+### func (*TCC) SetInverting
+
+```go
+func (tcc *TCC) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TCC) SetPeriod
+
+```go
+func (tcc *TCC) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this TCC peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the TCC peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TCC) Top
+
+```go
+func (tcc *TCC) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+tcc.Set (see tcc.Set for more information).
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*sam.SERCOM_USART_INT_Type
+	SERCOM		uint8
+	Interrupt	interrupt.Interrupt	// RXC interrupt
+}
+```
+
+UART on the SAMD51.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/metro-m4-airlift.md b/content/docs/reference/microcontrollers/machine/metro-m4-airlift.md
new file mode 100644
index 00000000..25ef2c18
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/metro-m4-airlift.md
@@ -0,0 +1,1726 @@
+
+---
+title: metro-m4-airlift
+---
+
+
+## Constants
+
+```go
+const (
+	D0	= PA23	// UART0 RX/PWM available
+	D1	= PA22	// UART0 TX/PWM available
+	D2	= PB17	// PWM available
+	D3	= PB16	// PWM available
+	D4	= PB13	// PWM available
+	D5	= PB14	// PWM available
+	D6	= PB15	// PWM available
+	D7	= PB12	// PWM available
+
+	D8	= PA21	// PWM available
+	D9	= PA20	// PWM available
+	D10	= PA18	// can be used for PWM or UART1 TX
+	D11	= PA19	// can be used for PWM or UART1 RX
+	D12	= PA17	// PWM available
+	D13	= PA16	// PWM available
+
+	D40	= PB22	// built-in neopixel
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A0	= PA02	// ADC/AIN[0]
+	A1	= PA05	// ADC/AIN[2]
+	A2	= PB06	// ADC/AIN[3]
+	A3	= PB00	// ADC/AIN[4] // NOTE: different between "airlift" and non-airlift versions
+	A4	= PB08	// ADC/AIN[5]
+	A5	= PB09	// ADC/AIN[10]
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	LED	= D13
+	WS2812	= D40
+)
+```
+
+
+
+```go
+const (
+	USBCDC_DM_PIN	= PA24
+	USBCDC_DP_PIN	= PA25
+)
+```
+
+USBCDC pins
+
+
+```go
+const (
+	UART_TX_PIN	= D1
+	UART_RX_PIN	= D0
+)
+```
+
+
+
+```go
+const (
+	UART2_TX_PIN	= PA04
+	UART2_RX_PIN	= PA07
+)
+```
+
+
+
+```go
+const (
+	NINA_BAUDRATE		= 115200
+	NINA_RESET_INVERTED	= true
+	NINA_SOFT_FLOWCONTROL	= true
+)
+```
+
+NINA-W102 settings
+
+
+```go
+const (
+	NINA_CS		= PA15
+	NINA_ACK	= PB04
+	NINA_GPIO0	= PB01
+	NINA_RESETN	= PB05
+
+	// pins used for the ESP32 connection do not allow hardware
+	// flow control, which is required. have to emulate with software.
+	NINA_TX		= PA04
+	NINA_RX		= PA07
+	NINA_CTS	= NINA_ACK
+	NINA_RTS	= NINA_GPIO0
+)
+```
+
+
+
+```go
+const (
+	SDA_PIN	= PB02	// SDA: SERCOM5/PAD[0]
+	SCL_PIN	= PB03	// SCL: SERCOM5/PAD[1]
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= PA13	// SCK:  SERCOM2/PAD[1]
+	SPI0_SDO_PIN	= PA12	// SDO: SERCOM2/PAD[0]
+	SPI0_SDI_PIN	= PA14	// SDI: SERCOM2/PAD[2]
+
+	NINA_SDO	= SPI0_SDO_PIN
+	NINA_SDI	= SPI0_SDI_PIN
+	NINA_SCK	= SPI0_SCK_PIN
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	SPI1_SCK_PIN	= D12	// SDI: SERCOM1/PAD[1]
+	SPI1_SDO_PIN	= D11	// SDO: SERCOM1/PAD[3]
+	SPI1_SDI_PIN	= D13	// SCK:  SERCOM1/PAD[0]
+)
+```
+
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinAnalog		PinMode	= 1
+	PinSERCOM		PinMode	= 2
+	PinSERCOMAlt		PinMode	= 3
+	PinTimer		PinMode	= 4
+	PinTimerAlt		PinMode	= 5
+	PinTCCPDEC		PinMode	= 6
+	PinCom			PinMode	= 7
+	PinSDHC			PinMode	= 8
+	PinI2S			PinMode	= 9
+	PinPCC			PinMode	= 10
+	PinGMAC			PinMode	= 11
+	PinACCLK		PinMode	= 12
+	PinCCL			PinMode	= 13
+	PinDigital		PinMode	= 14
+	PinInput		PinMode	= 15
+	PinInputPullup		PinMode	= 16
+	PinOutput		PinMode	= 17
+	PinTCCE			PinMode	= PinTimer
+	PinTCCF			PinMode	= PinTimerAlt
+	PinTCCG			PinMode	= PinTCCPDEC
+	PinInputPulldown	PinMode	= 18
+	PinCAN			PinMode	= 19
+	PinCAN0			PinMode	= PinSDHC
+	PinCAN1			PinMode	= PinCom
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
+	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
+	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	PA00	Pin	= 0
+	PA01	Pin	= 1
+	PA02	Pin	= 2
+	PA03	Pin	= 3
+	PA04	Pin	= 4
+	PA05	Pin	= 5
+	PA06	Pin	= 6
+	PA07	Pin	= 7
+	PA08	Pin	= 8	// peripherals: TCC0 channel 0, TCC1 channel 4, sercomI2CM0 SDA, sercomI2CM2 SDA
+	PA09	Pin	= 9	// peripherals: TCC0 channel 1, TCC1 channel 5, sercomI2CM0 SCL, sercomI2CM2 SCL
+	PA10	Pin	= 10	// peripherals: TCC0 channel 2, TCC1 channel 6
+	PA11	Pin	= 11	// peripherals: TCC0 channel 3, TCC1 channel 7
+	PA12	Pin	= 12	// peripherals: TCC0 channel 6, TCC1 channel 2, sercomI2CM2 SDA, sercomI2CM4 SDA
+	PA13	Pin	= 13	// peripherals: TCC0 channel 7, TCC1 channel 3, sercomI2CM2 SCL, sercomI2CM4 SCL
+	PA14	Pin	= 14	// peripherals: TCC2 channel 0, TCC1 channel 2
+	PA15	Pin	= 15	// peripherals: TCC2 channel 1, TCC1 channel 3
+	PA16	Pin	= 16	// peripherals: TCC1 channel 0, TCC0 channel 4, sercomI2CM1 SDA, sercomI2CM3 SDA
+	PA17	Pin	= 17	// peripherals: TCC1 channel 1, TCC0 channel 5, sercomI2CM1 SCL, sercomI2CM3 SCL
+	PA18	Pin	= 18	// peripherals: TCC1 channel 2, TCC0 channel 6
+	PA19	Pin	= 19	// peripherals: TCC1 channel 3, TCC0 channel 7
+	PA20	Pin	= 20	// peripherals: TCC1 channel 4, TCC0 channel 0
+	PA21	Pin	= 21	// peripherals: TCC1 channel 5, TCC0 channel 1
+	PA22	Pin	= 22	// peripherals: TCC1 channel 6, TCC0 channel 2, sercomI2CM3 SDA, sercomI2CM5 SDA
+	PA23	Pin	= 23	// peripherals: TCC1 channel 7, TCC0 channel 3, sercomI2CM3 SCL, sercomI2CM5 SCL
+	PA24	Pin	= 24	// peripherals: TCC2 channel 2
+	PA25	Pin	= 25	// peripherals: TCC2 channel 3
+	PA26	Pin	= 26
+	PA27	Pin	= 27
+	PA28	Pin	= 28
+	PA29	Pin	= 29
+	PA30	Pin	= 30	// peripherals: TCC2 channel 0
+	PA31	Pin	= 31	// peripherals: TCC2 channel 1
+	PB00	Pin	= 32
+	PB01	Pin	= 33
+	PB02	Pin	= 34	// peripherals: TCC2 channel 2
+	PB03	Pin	= 35	// peripherals: TCC2 channel 3
+	PB04	Pin	= 36
+	PB05	Pin	= 37
+	PB06	Pin	= 38
+	PB07	Pin	= 39
+	PB08	Pin	= 40
+	PB09	Pin	= 41
+	PB10	Pin	= 42	// peripherals: TCC0 channel 4, TCC1 channel 0
+	PB11	Pin	= 43	// peripherals: TCC0 channel 5, TCC1 channel 1
+	PB12	Pin	= 44	// peripherals: TCC3 channel 0, TCC0 channel 0
+	PB13	Pin	= 45	// peripherals: TCC3 channel 1, TCC0 channel 1
+	PB14	Pin	= 46	// peripherals: TCC4 channel 0, TCC0 channel 2
+	PB15	Pin	= 47	// peripherals: TCC4 channel 1, TCC0 channel 3
+	PB16	Pin	= 48	// peripherals: TCC3 channel 0, TCC0 channel 4
+	PB17	Pin	= 49	// peripherals: TCC3 channel 1, TCC0 channel 5
+	PB18	Pin	= 50	// peripherals: TCC1 channel 0
+	PB19	Pin	= 51	// peripherals: TCC1 channel 1
+	PB20	Pin	= 52	// peripherals: TCC1 channel 2
+	PB21	Pin	= 53	// peripherals: TCC1 channel 3
+	PB22	Pin	= 54
+	PB23	Pin	= 55
+	PB24	Pin	= 56
+	PB25	Pin	= 57
+	PB26	Pin	= 58	// peripherals: TCC1 channel 2
+	PB27	Pin	= 59	// peripherals: TCC1 channel 3
+	PB28	Pin	= 60	// peripherals: TCC1 channel 4
+	PB29	Pin	= 61	// peripherals: TCC1 channel 5
+	PB30	Pin	= 62	// peripherals: TCC4 channel 0, TCC0 channel 6
+	PB31	Pin	= 63	// peripherals: TCC4 channel 1, TCC0 channel 7
+	PC00	Pin	= 64
+	PC01	Pin	= 65
+	PC02	Pin	= 66
+	PC03	Pin	= 67
+	PC04	Pin	= 68	// peripherals: TCC0 channel 0
+	PC05	Pin	= 69	// peripherals: TCC0 channel 1
+	PC06	Pin	= 70
+	PC07	Pin	= 71
+	PC08	Pin	= 72
+	PC09	Pin	= 73
+	PC10	Pin	= 74	// peripherals: TCC0 channel 0, TCC1 channel 4
+	PC11	Pin	= 75	// peripherals: TCC0 channel 1, TCC1 channel 5
+	PC12	Pin	= 76	// peripherals: TCC0 channel 2, TCC1 channel 6
+	PC13	Pin	= 77	// peripherals: TCC0 channel 3, TCC1 channel 7
+	PC14	Pin	= 78	// peripherals: TCC0 channel 4, TCC1 channel 0
+	PC15	Pin	= 79	// peripherals: TCC0 channel 5, TCC1 channel 1
+	PC16	Pin	= 80	// peripherals: TCC0 channel 0
+	PC17	Pin	= 81	// peripherals: TCC0 channel 1
+	PC18	Pin	= 82	// peripherals: TCC0 channel 2
+	PC19	Pin	= 83	// peripherals: TCC0 channel 3
+	PC20	Pin	= 84	// peripherals: TCC0 channel 4
+	PC21	Pin	= 85	// peripherals: TCC0 channel 5
+	PC22	Pin	= 86	// peripherals: TCC0 channel 6
+	PC23	Pin	= 87	// peripherals: TCC0 channel 7
+	PC24	Pin	= 88
+	PC25	Pin	= 89
+	PC26	Pin	= 90
+	PC27	Pin	= 91
+	PC28	Pin	= 92
+	PC29	Pin	= 93
+	PC30	Pin	= 94
+	PC31	Pin	= 95
+	PD00	Pin	= 96
+	PD01	Pin	= 97
+	PD02	Pin	= 98
+	PD03	Pin	= 99
+	PD04	Pin	= 100
+	PD05	Pin	= 101
+	PD06	Pin	= 102
+	PD07	Pin	= 103
+	PD08	Pin	= 104	// peripherals: TCC0 channel 1, sercomI2CM6 SDA, sercomI2CM7 SDA
+	PD09	Pin	= 105	// peripherals: TCC0 channel 2, sercomI2CM6 SCL, sercomI2CM7 SCL
+	PD10	Pin	= 106	// peripherals: TCC0 channel 3
+	PD11	Pin	= 107	// peripherals: TCC0 channel 4
+	PD12	Pin	= 108	// peripherals: TCC0 channel 5
+	PD13	Pin	= 109	// peripherals: TCC0 channel 6
+	PD14	Pin	= 110
+	PD15	Pin	= 111
+	PD16	Pin	= 112
+	PD17	Pin	= 113
+	PD18	Pin	= 114
+	PD19	Pin	= 115
+	PD20	Pin	= 116	// peripherals: TCC1 channel 0
+	PD21	Pin	= 117	// peripherals: TCC1 channel 1
+	PD22	Pin	= 118
+	PD23	Pin	= 119
+	PD24	Pin	= 120
+	PD25	Pin	= 121
+	PD26	Pin	= 122
+	PD27	Pin	= 123
+	PD28	Pin	= 124
+	PD29	Pin	= 125
+	PD30	Pin	= 126
+	PD31	Pin	= 127
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	// SERCOM_FREQ_REF is always reference frequency on SAMD51 regardless of CPU speed.
+	SERCOM_FREQ_REF		= 48000000
+	SERCOM_FREQ_REF_GCLK0	= 120000000
+
+	// Default rise time in nanoseconds, based on 4.7K ohm pull up resistors
+	riseTimeNanoseconds	= 125
+
+	// wire bus states
+	wireUnknownState	= 0
+	wireIdleState		= 1
+	wireOwnerState		= 2
+	wireBusyState		= 3
+
+	// wire commands
+	wireCmdNoAction		= 0
+	wireCmdRepeatStart	= 1
+	wireCmdRead		= 2
+	wireCmdStop		= 3
+)
+```
+
+
+
+```go
+const (
+	QSPI_SCK	= PB10
+	QSPI_CS		= PB11
+	QSPI_DATA0	= PA08
+	QSPI_DATA1	= PA09
+	QSPI_DATA2	= PA10
+	QSPI_DATA3	= PA11
+)
+```
+
+The QSPI peripheral on ATSAMD51 is only available on the following pins
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (16s)
+	WatchdogMaxTimeout = (16384 * 1000) / 1024	// CYC16384/1024kHz
+)
+```
+
+
+
+```go
+const (
+	// these are SAMD51 specific.
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Pos	= 0
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Mask	= 0x3FFF
+
+	usb_DEVICE_PCKSIZE_SIZE_Pos	= 28
+	usb_DEVICE_PCKSIZE_SIZE_Mask	= 0x7
+
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Pos	= 14
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Mask	= 0x3FFF
+
+	NumberOfUSBEndpoints	= 8
+)
+```
+
+
+
+```go
+const HSRAM_SIZE = 0x00030000
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	UART1	= &sercomUSART3
+	UART2	= &sercomUSART0
+
+	DefaultUART	= UART1
+
+	UART_NINA	= UART2
+)
+```
+
+
+
+```go
+var (
+	I2C0 = sercomI2CM5
+)
+```
+
+I2C on the Metro M4.
+
+
+```go
+var (
+	SPI0		= sercomSPIM2
+	NINA_SPI	= SPI0
+)
+```
+
+SPI on the Metro M4.
+
+
+```go
+var SPI1 = sercomSPIM1
+```
+
+SPI1 on the Metro M4 on pins 11,12,13
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	DAC0	= DAC{Channel: 0}
+	DAC1	= DAC{Channel: 1}
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the SAMD51.
+
+
+```go
+var (
+	TCC0	= (*TCC)(sam.TCC0)
+	TCC1	= (*TCC)(sam.TCC1)
+	TCC2	= (*TCC)(sam.TCC2)
+	TCC3	= (*TCC)(sam.TCC3)
+	TCC4	= (*TCC)(sam.TCC4)
+)
+```
+
+This chip has five TCC peripherals, which have PWM as one feature.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) and 16 bytes (128 bits) are common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of cryptographically secure random data
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig)
+```
+
+Configure configures a ADCPin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type DAC
+
+```go
+type DAC struct {
+	Channel uint8
+}
+```
+
+DAC on the SAMD51.
+
+
+
+### func (DAC) Configure
+
+```go
+func (dac DAC) Configure(config DACConfig)
+```
+
+Configure the DAC.
+output pin must already be configured.
+
+
+### func (DAC) Set
+
+```go
+func (dac DAC) Set(value uint16) error
+```
+
+Set writes a single 16-bit value to the DAC.
+Since the ATSAMD51 only has a 12-bit DAC, the passed-in value will be scaled down.
+
+
+
+
+## type DACConfig
+
+```go
+type DACConfig struct {
+}
+```
+
+DACConfig placeholder for future expansion.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*sam.SERCOM_I2CM_Type
+	SERCOM	uint8
+}
+```
+
+I2C on the SAMD51.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteByte
+
+```go
+func (i2c *I2C) WriteByte(data byte) error
+```
+
+WriteByte writes a single byte to the I2C bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when configured as an input or as
+an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+### func (Pin) Toggle
+
+```go
+func (p Pin) Toggle()
+```
+
+Toggle switches an output pin from low to high or from high to low.
+Warning: only use this on an output pin!
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*sam.SERCOM_SPIM_Type
+	SERCOM	uint8
+}
+```
+
+SPI
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type TCC
+
+```go
+type TCC sam.TCC_Type
+```
+
+TCC is one timer peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this timer peripheral at
+once.
+
+
+
+### func (*TCC) Channel
+
+```go
+func (tcc *TCC) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin. Note that one channel may be
+shared between multiple pins, and so will have the same duty cycle. If this
+is not desirable, look for a different TCC or consider using a different pin.
+
+
+### func (*TCC) Configure
+
+```go
+func (tcc *TCC) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this TCC.
+
+
+### func (*TCC) Counter
+
+```go
+func (tcc *TCC) Counter() uint32
+```
+
+Counter returns the current counter value of the timer in this TCC
+peripheral. It may be useful for debugging.
+
+
+### func (*TCC) Set
+
+```go
+func (tcc *TCC) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle, in other words the fraction of time the channel output is high (or low
+when inverted). For example, to set it to a 25% duty cycle, use:
+
+	tcc.Set(channel, tcc.Top() / 4)
+
+tcc.Set(channel, 0) will set the output to low and tcc.Set(channel,
+tcc.Top()) will set the output to high, assuming the output isn't inverted.
+
+
+### func (*TCC) SetInverting
+
+```go
+func (tcc *TCC) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TCC) SetPeriod
+
+```go
+func (tcc *TCC) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this TCC peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the TCC peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TCC) Top
+
+```go
+func (tcc *TCC) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+tcc.Set (see tcc.Set for more information).
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*sam.SERCOM_USART_INT_Type
+	SERCOM		uint8
+	Interrupt	interrupt.Interrupt	// RXC interrupt
+}
+```
+
+UART on the SAMD51.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/microbit.md b/content/docs/reference/microcontrollers/machine/microbit.md
new file mode 100644
index 00000000..547e4ffe
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/microbit.md
@@ -0,0 +1,1163 @@
+
+---
+title: microbit
+---
+
+
+## Constants
+
+```go
+const HasLowFrequencyCrystal = false
+```
+
+The micro:bit does not have a 32kHz crystal on board.
+
+
+```go
+const (
+	P0	= P0_03
+	P1	= P0_02
+	P2	= P0_01
+	P3	= P0_04
+	P4	= P0_05
+	P5	= P0_17
+	P6	= P0_12
+	P7	= P0_11
+	P8	= P0_18
+	P9	= P0_10
+	P10	= P0_06
+	P11	= P0_26
+	P12	= P0_20
+	P13	= P0_23
+	P14	= P0_22
+	P15	= P0_21
+	P16	= P0_16
+)
+```
+
+GPIO/Analog pins
+
+
+```go
+const (
+	BUTTONA	= P0_17
+	BUTTONB	= P0_26
+	BUTTON	= BUTTONA
+)
+```
+
+Buttons on the micro:bit (A and B)
+
+
+```go
+const (
+	UART_TX_PIN	= P0_24
+	UART_RX_PIN	= P0_25
+)
+```
+
+UART pins
+
+
+```go
+const (
+	ADC0	= P0_03	// P0 on the board
+	ADC1	= P0_02	// P1 on the board
+	ADC2	= P0_01	// P2 on the board
+)
+```
+
+ADC pins
+
+
+```go
+const (
+	SDA_PIN	= P0_30	// P20 on the board
+	SCL_PIN	= P0_00	// P19 on the board
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= P0_23	// P13 on the board
+	SPI0_SDO_PIN	= P0_21	// P15 on the board
+	SPI0_SDI_PIN	= P0_22	// P14 on the board
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	LED_COL_1	= P0_04
+	LED_COL_2	= P0_05
+	LED_COL_3	= P0_06
+	LED_COL_4	= P0_07
+	LED_COL_5	= P0_08
+	LED_COL_6	= P0_09
+	LED_COL_7	= P0_10
+	LED_COL_8	= P0_11
+	LED_COL_9	= P0_12
+	LED_ROW_1	= P0_13
+	LED_ROW_2	= P0_14
+	LED_ROW_3	= P0_15
+)
+```
+
+LED matrix pins
+
+
+```go
+const (
+	P0_00	Pin	= 0
+	P0_01	Pin	= 1
+	P0_02	Pin	= 2
+	P0_03	Pin	= 3
+	P0_04	Pin	= 4
+	P0_05	Pin	= 5
+	P0_06	Pin	= 6
+	P0_07	Pin	= 7
+	P0_08	Pin	= 8
+	P0_09	Pin	= 9
+	P0_10	Pin	= 10
+	P0_11	Pin	= 11
+	P0_12	Pin	= 12
+	P0_13	Pin	= 13
+	P0_14	Pin	= 14
+	P0_15	Pin	= 15
+	P0_16	Pin	= 16
+	P0_17	Pin	= 17
+	P0_18	Pin	= 18
+	P0_19	Pin	= 19
+	P0_20	Pin	= 20
+	P0_21	Pin	= 21
+	P0_22	Pin	= 22
+	P0_23	Pin	= 23
+	P0_24	Pin	= 24
+	P0_25	Pin	= 25
+	P0_26	Pin	= 26
+	P0_27	Pin	= 27
+	P0_28	Pin	= 28
+	P0_29	Pin	= 29
+	P0_30	Pin	= 30
+	P0_31	Pin	= 31
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
+	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
+	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	// UART0 is the hardware UART on the NRF SoC.
+	_UART0	= UART{Buffer: NewRingBuffer()}
+	UART0	= &_UART0
+)
+```
+
+UART
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	SPI0	= &SPI{Bus: nrf.SPI0}
+	SPI1	= &SPI{Bus: nrf.SPI1}
+)
+```
+
+There are 2 SPI interfaces on the NRF51.
+
+
+```go
+var (
+	I2C0	= &I2C{Bus: nrf.TWI0}
+	I2C1	= &I2C{Bus: nrf.TWI1}
+)
+```
+
+There are 2 I2C interfaces on the NRF.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (ret uint32, err error)
+```
+
+GetRNG returns 32 bits of non-deterministic random data based on internal thermal noise.
+According to Nordic's documentation, the random output is suitable for cryptographic purposes.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() int32
+```
+
+ReadTemperature reads the silicon die temperature of the chip. The return
+value is in milli-celsius.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(ADCConfig)
+```
+
+Configure configures an ADC pin to be able to read analog data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*nrf.TWI_Type
+	mode	I2CMode
+}
+```
+
+I2C on the NRF51 and NRF52.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) (err error)
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus *nrf.SPI_Type
+}
+```
+
+SPI on the NRF.
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer *RingBuffer
+}
+```
+
+UART on the NRF.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/nano-33-ble.md b/content/docs/reference/microcontrollers/machine/nano-33-ble.md
new file mode 100644
index 00000000..58060508
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/nano-33-ble.md
@@ -0,0 +1,1558 @@
+
+---
+title: nano-33-ble
+---
+
+
+## Constants
+
+```go
+const HasLowFrequencyCrystal = true
+```
+
+
+
+```go
+const (
+	D2	Pin	= P1_11
+	D3	Pin	= P1_12
+	D4	Pin	= P1_15
+	D5	Pin	= P1_13
+	D6	Pin	= P1_14
+	D7	Pin	= P0_23
+	D8	Pin	= P0_21
+	D9	Pin	= P0_27
+	D10	Pin	= P1_02
+	D11	Pin	= P1_01
+	D12	Pin	= P1_08
+	D13	Pin	= P0_13
+)
+```
+
+Digital Pins
+
+
+```go
+const (
+	A0	Pin	= P0_04
+	A1	Pin	= P0_05
+	A2	Pin	= P0_30
+	A3	Pin	= P0_29
+	A4	Pin	= P0_31
+	A5	Pin	= P0_02
+	A6	Pin	= P0_28
+	A7	Pin	= P0_03
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	LED		= LED_BUILTIN
+	LED1		= LED_RED
+	LED2		= LED_GREEN
+	LED3		= LED_BLUE
+	LED_BUILTIN	= P0_13
+	LED_RED		= P0_24
+	LED_GREEN	= P0_16
+	LED_BLUE	= P0_06
+	LED_PWR		= P1_09
+)
+```
+
+Onboard LEDs
+
+
+```go
+const (
+	UART_RX_PIN	= P1_10
+	UART_TX_PIN	= P1_03
+)
+```
+
+UART0 pins
+
+
+```go
+const (
+	// Defaults to internal
+	SDA_PIN	= SDA1_PIN
+	SCL_PIN	= SCL1_PIN
+
+	// I2C0 (external) pins
+	SDA0_PIN	= P0_31
+	SCL0_PIN	= P0_02
+
+	// I2C1 (internal) pins
+	SDA1_PIN	= P0_14
+	SCL1_PIN	= P0_15
+
+	I2C_PULLUP	= P1_00	// Set high for I2C to work
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= P0_13
+	SPI0_SDO_PIN	= P1_01
+	SPI0_SDI_PIN	= P1_08
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	APDS_INT	= P0_19	// Proximity (APDS9960) interrupt pin
+
+	LSM_PWR	= P0_22	// IMU (LSM9DS1) power
+	LPS_PWR	= P0_22	// Pressure (LPS22HB) power
+	HTS_PWR	= P0_22	// Humidity (HTS221) power
+
+	MIC_PWR	= P0_17	// Microphone (MP34DT06JTR) power
+	MIC_CLK	= P0_26
+	MIC_DIN	= P0_25
+)
+```
+
+Peripherals
+
+
+```go
+const (
+	P0_00	Pin	= 0
+	P0_01	Pin	= 1
+	P0_02	Pin	= 2
+	P0_03	Pin	= 3
+	P0_04	Pin	= 4
+	P0_05	Pin	= 5
+	P0_06	Pin	= 6
+	P0_07	Pin	= 7
+	P0_08	Pin	= 8
+	P0_09	Pin	= 9
+	P0_10	Pin	= 10
+	P0_11	Pin	= 11
+	P0_12	Pin	= 12
+	P0_13	Pin	= 13
+	P0_14	Pin	= 14
+	P0_15	Pin	= 15
+	P0_16	Pin	= 16
+	P0_17	Pin	= 17
+	P0_18	Pin	= 18
+	P0_19	Pin	= 19
+	P0_20	Pin	= 20
+	P0_21	Pin	= 21
+	P0_22	Pin	= 22
+	P0_23	Pin	= 23
+	P0_24	Pin	= 24
+	P0_25	Pin	= 25
+	P0_26	Pin	= 26
+	P0_27	Pin	= 27
+	P0_28	Pin	= 28
+	P0_29	Pin	= 29
+	P0_30	Pin	= 30
+	P0_31	Pin	= 31
+	P1_00	Pin	= 32
+	P1_01	Pin	= 33
+	P1_02	Pin	= 34
+	P1_03	Pin	= 35
+	P1_04	Pin	= 36
+	P1_05	Pin	= 37
+	P1_06	Pin	= 38
+	P1_07	Pin	= 39
+	P1_08	Pin	= 40
+	P1_09	Pin	= 41
+	P1_10	Pin	= 42
+	P1_11	Pin	= 43
+	P1_12	Pin	= 44
+	P1_13	Pin	= 45
+	P1_14	Pin	= 46
+	P1_15	Pin	= 47
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
+	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
+	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 36h)
+	WatchdogMaxTimeout = (0xffffffff * 1000) / 32768
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	// UART0 is the hardware UART on the NRF SoC.
+	_UART0	= UART{Buffer: NewRingBuffer()}
+	UART0	= &_UART0
+)
+```
+
+UART
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	PWM0	= &PWM{PWM: nrf.PWM0}
+	PWM1	= &PWM{PWM: nrf.PWM1}
+	PWM2	= &PWM{PWM: nrf.PWM2}
+	PWM3	= &PWM{PWM: nrf.PWM3}
+)
+```
+
+PWM
+
+
+```go
+var (
+	I2C0	= &I2C{Bus: nrf.TWIM0, BusT: nrf.TWIS0}
+	I2C1	= &I2C{Bus: nrf.TWIM1, BusT: nrf.TWIS1}
+)
+```
+
+There are 2 I2C interfaces on the NRF.
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	SPI0	= &SPI{Bus: nrf.SPIM0, buf: new([1]byte)}
+	SPI1	= &SPI{Bus: nrf.SPIM1, buf: new([1]byte)}
+	SPI2	= &SPI{Bus: nrf.SPIM2, buf: new([1]byte)}
+)
+```
+
+There are 3 SPI interfaces on the NRF528xx.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader resets the chip into the serial bootloader. After
+reset, it can be flashed using serial/nrfutil.
+
+
+### func EnterOTABootloader
+
+```go
+func EnterOTABootloader()
+```
+
+EnterOTABootloader resets the chip into the bootloader so that it can be
+flashed via an OTA update
+
+
+### func EnterSerialBootloader
+
+```go
+func EnterSerialBootloader()
+```
+
+EnterSerialBootloader resets the chip into the serial bootloader. After
+reset, it can be flashed using serial/nrfutil.
+
+
+### func EnterUF2Bootloader
+
+```go
+func EnterUF2Bootloader()
+```
+
+EnterUF2Bootloader resets the chip into the UF2 bootloader. After reset, it
+can be flashed via nrfutil or by copying a UF2 file to the mass storage device
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (ret uint32, err error)
+```
+
+GetRNG returns 32 bits of non-deterministic random data based on internal thermal noise.
+According to Nordic's documentation, the random output is suitable for cryptographic purposes.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() int32
+```
+
+ReadTemperature reads the silicon die temperature of the chip. The return
+value is in milli-celsius.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USBHID (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (*ADC) Configure
+
+```go
+func (a *ADC) Configure(config ADCConfig)
+```
+
+Configure configures an ADC pin to be able to read analog data.
+Reference voltage can be 150, 300, 600, 1200, 1800, 2400, 3000(default), 3600 mV
+Resolution can be 8, 10, 12(default), 14 bits
+SampleTime will be ceiled to 3(default), 5, 10, 15, 20 or 40(max) µS respectively
+Samples can be 1(default), 2, 4, 8, 16, 32, 64, 128, 256 samples
+
+
+### func (*ADC) Get
+
+```go
+func (a *ADC) Get() uint16
+```
+
+Get returns the current value of an ADC pin in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*nrf.TWIM_Type	// Called Bus to align with Bus field in nrf51
+	BusT	*nrf.TWIS_Type
+	mode	I2CMode
+}
+```
+
+I2C on the NRF528xx.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint8) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+Reply supplies the response data the controller.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) (err error)
+```
+
+Tx does a single I2C transaction at the specified address (when in controller mode).
+
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+WaitForEvent blocks the current go-routine until an I2C event is received (when in Target mode).
+
+The passed buffer will be populated for receive events, with the number of bytes
+received returned in count.  For other event types, buf is not modified and a count
+of zero is returned.
+
+For request events, the caller MUST call `Reply` to avoid hanging the i2c bus indefinitely.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDM
+
+```go
+type PDM struct {
+	device		*nrf.PDM_Type
+	defaultBuffer	int16
+}
+```
+
+PDM represents a PDM device
+
+
+
+### func (*PDM) Configure
+
+```go
+func (pdm *PDM) Configure(config PDMConfig) error
+```
+
+Configure is intended to set up the PDM interface prior to use.
+
+
+### func (*PDM) Read
+
+```go
+func (pdm *PDM) Read(buf []int16) (uint32, error)
+```
+
+Read stores a set of samples in the given target buffer.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWM
+
+```go
+type PWM struct {
+	PWM	*nrf.PWM_Type
+
+	channelValues	[4]volatile.Register16
+}
+```
+
+PWM is one PWM peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this PWM peripheral at
+once.
+
+
+
+### func (*PWM) Channel
+
+```go
+func (pwm *PWM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*PWM) Configure
+
+```go
+func (pwm *PWM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+On the nRF52 series, the maximum period is around 0.26s.
+
+
+### func (*PWM) Set
+
+```go
+func (pwm *PWM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	ch.Set(ch.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*PWM) SetInverting
+
+```go
+func (pwm *PWM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*PWM) SetPeriod
+
+```go
+func (pwm *PWM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*PWM) Top
+
+```go
+func (pwm *PWM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*nrf.SPIM_Type
+	buf	*[1]byte	// 1-byte buffer for the Transfer method
+}
+```
+
+SPI on the NRF.
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to set up the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous
+write/read interface, there must always be the same number of bytes written
+as bytes read. Therefore, if the number of bytes don't match it will be
+padded until they fit: if len(w) > len(r) the extra bytes received will be
+dropped and if len(w) < len(r) extra 0 bytes will be sent.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer *RingBuffer
+}
+```
+
+UART on the NRF.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/nano-rp2040.md b/content/docs/reference/microcontrollers/machine/nano-rp2040.md
new file mode 100644
index 00000000..651c8639
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/nano-rp2040.md
@@ -0,0 +1,1736 @@
+
+---
+title: nano-rp2040
+---
+
+
+## Constants
+
+```go
+const (
+	D2	Pin	= GPIO25
+	D3	Pin	= GPIO15
+	D4	Pin	= GPIO16
+	D5	Pin	= GPIO17
+	D6	Pin	= GPIO18
+	D7	Pin	= GPIO19
+	D8	Pin	= GPIO20
+	D9	Pin	= GPIO21
+	D10	Pin	= GPIO5
+	D11	Pin	= GPIO7
+	D12	Pin	= GPIO4
+	D13	Pin	= GPIO6
+	D14	Pin	= GPIO26
+	D15	Pin	= GPIO27
+	D16	Pin	= GPIO28
+	D17	Pin	= GPIO29
+	D18	Pin	= GPIO12
+	D19	Pin	= GPIO13
+)
+```
+
+Digital Pins
+
+
+```go
+const (
+	A0	Pin	= ADC0
+	A1	Pin	= ADC1
+	A2	Pin	= ADC2
+	A3	Pin	= ADC3
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	LED = GPIO6
+)
+```
+
+Onboard LED
+
+
+```go
+const (
+	I2C0_SDA_PIN	Pin	= GPIO12
+	I2C0_SCL_PIN	Pin	= GPIO13
+
+	I2C1_SDA_PIN	Pin	= GPIO18
+	I2C1_SCL_PIN	Pin	= GPIO19
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	Pin	= GPIO6
+	SPI0_SDO_PIN	Pin	= GPIO7
+	SPI0_SDI_PIN	Pin	= GPIO4
+
+	// GPIO22 does not have SPI functionality so we set it to avoid interfering with NINA.
+	SPI1_SCK_PIN	Pin	= GPIO22
+	SPI1_SDO_PIN	Pin	= GPIO22
+	SPI1_SDI_PIN	Pin	= GPIO22
+)
+```
+
+SPI pins. SPI1 not available on Nano RP2040 Connect.
+
+
+```go
+const (
+	NINA_SCK	Pin	= GPIO14
+	NINA_SDO	Pin	= GPIO11
+	NINA_SDI	Pin	= GPIO8
+
+	NINA_CS		Pin	= GPIO9
+	NINA_ACK	Pin	= GPIO10
+	NINA_GPIO0	Pin	= GPIO2
+	NINA_RESETN	Pin	= GPIO3
+
+	NINA_TX		Pin	= GPIO8
+	NINA_RX		Pin	= GPIO9
+	NINA_CTS	Pin	= GPIO10
+	NINA_RTS	Pin	= GPIO11
+)
+```
+
+NINA-W102 Pins
+
+
+```go
+const (
+	NINA_BAUDRATE		= 115200
+	NINA_RESET_INVERTED	= true
+	NINA_SOFT_FLOWCONTROL	= false
+)
+```
+
+NINA-W102 settings
+
+
+```go
+const (
+	UART0_TX_PIN	= GPIO0
+	UART0_RX_PIN	= GPIO1
+	UART_TX_PIN	= UART0_TX_PIN
+	UART_RX_PIN	= UART0_RX_PIN
+)
+```
+
+UART pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	LS_SE0	= 0b00
+	LS_J	= 0b01
+	LS_K	= 0b10
+	LS_SE1	= 0b11
+)
+```
+
+
+
+```go
+const (
+	cpuFreq			= 200 * MHz
+	_NUMBANK0_GPIOS		= 30
+	_NUMBANK0_IRQS		= 4
+	_NUMIRQ			= 32
+	rp2350ExtraReg		= 0
+	RESETS_RESET_Msk	= 0x01ffffff
+	initUnreset		= rp.RESETS_RESET_ADC |
+		rp.RESETS_RESET_RTC |
+		rp.RESETS_RESET_SPI0 |
+		rp.RESETS_RESET_SPI1 |
+		rp.RESETS_RESET_UART0 |
+		rp.RESETS_RESET_UART1 |
+		rp.RESETS_RESET_USBCTRL
+	initDontReset	= rp.RESETS_RESET_IO_QSPI |
+		rp.RESETS_RESET_PADS_QSPI |
+		rp.RESETS_RESET_PLL_USB |
+		rp.RESETS_RESET_USBCTRL |
+		rp.RESETS_RESET_SYSCFG |
+		rp.RESETS_RESET_PLL_SYS
+	padEnableMask	= rp.PADS_BANK0_GPIO0_IE_Msk |
+		rp.PADS_BANK0_GPIO0_OD_Msk
+)
+```
+
+
+
+```go
+const (
+	PinOutput	PinMode	= iota
+	PinInput
+	PinInputPulldown
+	PinInputPullup
+	PinAnalog
+	PinUART
+	PinPWM
+	PinI2C
+	PinSPI
+	PinPIO0
+	PinPIO1
+)
+```
+
+
+
+```go
+const (
+	ADC0	Pin	= GPIO26
+	ADC1	Pin	= GPIO27
+	ADC2	Pin	= GPIO28
+	ADC3	Pin	= GPIO29
+
+	thermADC	= 30
+)
+```
+
+Analog pins on RP2040.
+
+
+```go
+const (
+	// Edge falling
+	PinFalling	PinChange	= 4 << iota
+	// Edge rising
+	PinRising
+
+	PinToggle	= PinFalling | PinRising
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// GPIO pins
+	GPIO0	Pin	= 0	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO1	Pin	= 1	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO2	Pin	= 2	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO3	Pin	= 3	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO4	Pin	= 4	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO5	Pin	= 5	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO6	Pin	= 6	// peripherals: PWM3 channel A, I2C1 SDA
+	GPIO7	Pin	= 7	// peripherals: PWM3 channel B, I2C1 SCL
+	GPIO8	Pin	= 8	// peripherals: PWM4 channel A, I2C0 SDA
+	GPIO9	Pin	= 9	// peripherals: PWM4 channel B, I2C0 SCL
+	GPIO10	Pin	= 10	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO11	Pin	= 11	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO12	Pin	= 12	// peripherals: PWM6 channel A, I2C0 SDA
+	GPIO13	Pin	= 13	// peripherals: PWM6 channel B, I2C0 SCL
+	GPIO14	Pin	= 14	// peripherals: PWM7 channel A, I2C1 SDA
+	GPIO15	Pin	= 15	// peripherals: PWM7 channel B, I2C1 SCL
+	GPIO16	Pin	= 16	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO17	Pin	= 17	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO18	Pin	= 18	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO19	Pin	= 19	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO20	Pin	= 20	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO21	Pin	= 21	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO22	Pin	= 22	// peripherals: PWM3 channel A
+	GPIO23	Pin	= 23	// peripherals: PWM3 channel B
+	GPIO24	Pin	= 24	// peripherals: PWM4 channel A
+	GPIO25	Pin	= 25	// peripherals: PWM4 channel B
+	GPIO26	Pin	= 26	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO27	Pin	= 27	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO28	Pin	= 28	// peripherals: PWM6 channel A
+	GPIO29	Pin	= 29	// peripherals: PWM6 channel B
+)
+```
+
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 8.3s).
+	//
+	// Nominal 1us per watchdog tick, 24-bit counter,
+	// but due to errata two ticks consumed per 1us.
+	// See: Errata RP2040-E1
+	WatchdogMaxTimeout = (rp.WATCHDOG_LOAD_LOAD_Msk / 1000) / 2
+)
+```
+
+
+
+```go
+const XOSC_STARTUP_DELAY_MULTIPLIER = 64
+```
+
+On some boards, the XOSC can take longer than usual to stabilize. On such
+boards, this is needed to avoid a hard fault on boot/reset. Refer to
+PICO_XOSC_STARTUP_DELAY_MULTIPLIER in the Pico SDK for additional details.
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	NINA_SPI = SPI1
+)
+```
+
+
+
+```go
+var UART_NINA = UART1
+```
+
+UART_NINA on the Arduino Nano RP2040 connects to the NINA HCI.
+
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	UART0	= &_UART0
+	_UART0	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART0,
+	}
+
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART1,
+	}
+)
+```
+
+UART on the RP2040
+
+
+```go
+var RTC = (*rtcType)(unsafe.Pointer(rp.RTC))
+```
+
+
+
+```go
+var (
+	ErrRtcDelayTooSmall	= errors.New("RTC interrupt deplay is too small, shall be at least 1 second")
+	ErrRtcDelayTooLarge	= errors.New("RTC interrupt deplay is too large, shall be no more than 1 day")
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	I2C0	= &_I2C0
+	_I2C0	= I2C{
+		Bus: rp.I2C0,
+	}
+	I2C1	= &_I2C1
+	_I2C1	= I2C{
+		Bus: rp.I2C1,
+	}
+)
+```
+
+I2C on the RP2040/RP2350
+
+
+```go
+var (
+	ErrBadPeriod = errors.New("period outside valid range 8ns..268ms")
+)
+```
+
+
+
+```go
+var (
+	PWM0	= getPWMGroup(0)
+	PWM1	= getPWMGroup(1)
+	PWM2	= getPWMGroup(2)
+	PWM3	= getPWMGroup(3)
+	PWM4	= getPWMGroup(4)
+	PWM5	= getPWMGroup(5)
+	PWM6	= getPWMGroup(6)
+	PWM7	= getPWMGroup(7)
+)
+```
+
+Hardware Pulse Width Modulation (PWM) API
+PWM peripherals available on RP2040. Each peripheral has 2 pins available for
+a total of 16 available PWM outputs. Some pins may not be available on some boards.
+
+The RP2040 PWM block has 8 identical slices. Each slice can drive two PWM output signals, or
+measure the frequency or duty cycle of an input signal. This gives a total of up to 16 controllable
+PWM outputs. All 30 GPIOs can be driven by the PWM block
+
+The PWM hardware functions by continuously comparing the input value to a free-running counter. This produces a
+toggling output where the amount of time spent at the high output level is proportional to the input value. The fraction of
+time spent at the high signal level is known as the duty cycle of the signal.
+
+The default behaviour of a PWM slice is to count upward until the wrap value (\ref pwm_config_set_wrap) is reached, and then
+immediately wrap to 0. PWM slices also offer a phase-correct mode, where the counter starts to count downward after
+reaching TOP, until it reaches 0 again.
+
+
+```go
+var (
+	SPI0	= &SPI{
+		Bus: rp.SPI0,
+	}
+	SPI1	= &SPI{
+		Bus: rp.SPI1,
+	}
+)
+```
+
+SPI on the RP2040
+
+
+```go
+var (
+	ErrLSBNotSupported	= errors.New("SPI LSB unsupported on PL022")
+	ErrSPITimeout		= errors.New("SPI timeout")
+	ErrSPIBaud		= errors.New("SPI baud too low or above 66.5Mhz")
+	errSPIInvalidSDI	= errors.New("invalid SPI SDI pin")
+	errSPIInvalidSDO	= errors.New("invalid SPI SDO pin")
+	errSPIInvalidSCK	= errors.New("invalid SPI SCK pin")
+)
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the RP2040.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ChipVersion
+
+```go
+func ChipVersion() uint8
+```
+
+ChipVersion returns the version of the chip. 1 is returned for B0 and B1
+chip.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func CurrentCore
+
+```go
+func CurrentCore() int
+```
+
+CurrentCore returns the core number the call was made from.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of semi-random data based on ring oscillator.
+
+Unlike some other implementations of GetRNG, these random numbers are not
+cryptographically secure and must not be used for cryptographic operations
+(nonces, etc).
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC resets the ADC peripheral.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func NumCores
+
+```go
+func NumCores() int
+```
+
+NumCores returns number of cores available on the device.
+
+
+### func PWMPeripheral
+
+```go
+func PWMPeripheral(pin Pin) (sliceNum uint8, err error)
+```
+
+Peripheral returns the RP2040 PWM peripheral which ranges from 0 to 7. Each
+PWM peripheral has 2 channels, A and B which correspond to 0 and 1 in the program.
+This number corresponds to the package's PWM0 throughout PWM7 handles
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() (millicelsius int32)
+```
+
+ReadTemperature does a one-shot sample of the internal temperature sensor and returns a milli-celsius reading.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig) error
+```
+
+Configure sets the ADC pin to analog input mode.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns a one-shot ADC sample reading.
+
+
+### func (ADC) GetADCChannel
+
+```go
+func (a ADC) GetADCChannel() (c ADCChannel, err error)
+```
+
+GetADCChannel returns the channel associated with the ADC pin.
+
+
+
+
+## type ADCChannel
+
+```go
+type ADCChannel uint8
+```
+
+ADCChannel is the ADC peripheral mux channel. 0-4.
+
+
+
+### func (ADCChannel) Configure
+
+```go
+func (c ADCChannel) Configure(config ADCConfig) error
+```
+
+Configure sets the channel's associated pin to analog input mode.
+The powered on temperature sensor increases ADC_AVDD current by approximately 40 μA.
+
+
+### func (ADCChannel) Pin
+
+```go
+func (c ADCChannel) Pin() (p Pin, err error)
+```
+
+The Pin method returns the GPIO Pin associated with the ADC mux channel, if it has one.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*rp.I2C0_Type
+	mode		I2CMode
+	txInProgress	bool
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure initializes i2c peripheral and configures I2C config's pins passed.
+Here's a list of valid SDA and SCL GPIO pins on bus I2C0 of the rp2040:
+
+	SDA: 0, 4, 8, 12, 16, 20
+	SCL: 1, 5, 9, 13, 17, 21
+
+Same as above for I2C1 bus:
+
+	SDA: 2, 6, 10, 14, 18, 26
+	SCL: 3, 7, 11, 15, 19, 27
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint16) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx performs a write and then a read transfer placing the result in
+in r.
+
+Passing a nil value for w or r skips the transfer corresponding to write
+or read, respectively.
+
+	i2c.Tx(addr, nil, r)
+
+Performs only a read transfer.
+
+	i2c.Tx(addr, w, nil)
+
+Performs only a write transfer.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	// SDA/SCL Serial Data and clock pins. Refer to datasheet to see
+	// which pins match the desired bus.
+	SDA, SCL	Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure configures the gpio pin as per mode.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get reads the pin value.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set drives the pin high if value is true else drives it low.
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+PinChange represents one or more trigger events that can happen on a given GPIO pin
+on the RP2040. ORed PinChanges are valid input to most IRQ functions.
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus *rp.SPI0_Type
+}
+```
+
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup/initialize the SPI interface.
+Default baudrate of 4MHz is used if Frequency == 0. Default
+word length (data bits) is 8.
+Below is a list of GPIO pins corresponding to SPI0 bus on the rp2040:
+
+	SI : 0, 4, 17  a.k.a RX and MISO (if rp2040 is master)
+	SO : 3, 7, 19  a.k.a TX and MOSI (if rp2040 is master)
+	SCK: 2, 6, 18
+
+SPI1 bus GPIO pins:
+
+	SI : 8, 12
+	SO : 11, 15
+	SCK: 10, 14
+
+No pin configuration is needed of SCK, SDO and SDI needed after calling Configure.
+
+
+### func (*SPI) GetBaudRate
+
+```go
+func (spi *SPI) GetBaudRate() uint32
+```
+
+
+
+### func (*SPI) PrintRegs
+
+```go
+func (spi *SPI) PrintRegs()
+```
+
+PrintRegs prints SPI's peripheral common registries current values
+
+
+### func (*SPI) SetBaudRate
+
+```go
+func (spi *SPI) SetBaudRate(br uint32) error
+```
+
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Write a single byte and read a single byte from TX/RX FIFO.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) (err error)
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+Remark: This implementation (RP2040) allows reading into buffer with a custom repeated
+value on tx.
+
+	spi.Tx([]byte{0xff}, rx) // may cause unwanted heap allocations.
+
+This form sends 0xff and puts the result into rx buffer. Useful for reading from SD cards
+which require 0xff input on SI.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	// LSB not supported on rp2040.
+	LSBFirst	bool
+	// Mode's two most LSB are CPOL and CPHA. i.e. Mode==2 (0b10) is CPOL=1, CPHA=0
+	Mode	uint8
+	// Serial clock pin
+	SCK	Pin
+	// TX or Serial Data Out (MOSI if rp2040 is master)
+	SDO	Pin
+	// RX or Serial Data In (MISO if rp2040 is master)
+	SDI	Pin
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*rp.UART0_Type
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the RP2040.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the baudrate to be used for the UART.
+
+
+### func (*UART) SetFormat
+
+```go
+func (uart *UART) SetFormat(databits, stopbits uint8, parity UARTParity) error
+```
+
+SetFormat for number of data bits, stop bits, and parity for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) ClearStallEPIn
+
+```go
+func (dev *USBDevice) ClearStallEPIn(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB IN endpoint.
+
+
+### func (*USBDevice) ClearStallEPOut
+
+```go
+func (dev *USBDevice) ClearStallEPOut(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB OUT endpoint.
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+### func (*USBDevice) SetStallEPIn
+
+```go
+func (dev *USBDevice) SetStallEPIn(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB IN endpoint.
+
+
+### func (*USBDevice) SetStallEPOut
+
+```go
+func (dev *USBDevice) SetStallEPOut(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB OUT endpoint.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/nicenano.md b/content/docs/reference/microcontrollers/machine/nicenano.md
new file mode 100644
index 00000000..8bb9e9ee
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/nicenano.md
@@ -0,0 +1,1533 @@
+
+---
+title: nicenano
+---
+
+
+## Constants
+
+```go
+const HasLowFrequencyCrystal = true
+```
+
+
+
+```go
+const (
+	D006	= P0_06
+	D008	= P0_08
+	D017	= P0_17
+	D020	= P0_20
+	D022	= P0_22
+	D024	= P0_24
+	D100	= P1_00
+	D011	= P0_11
+	D104	= P1_04
+	D106	= P1_06
+
+	D004	= P0_04	// AIN2; P0.04 (AIN2) is used to read the voltage of the battery via ADC. It can’t be used for any other function.
+	D013	= P0_13	// VCC 3.3V; P0.13 on VCC shuts off the power to VCC when you set it to high; This saves on battery immensely for LEDs of all kinds that eat power even when off
+	D115	= P1_15
+	D113	= P1_13
+	D031	= P0_31	// AIN7
+	D029	= P0_29	// AIN5
+	D002	= P0_02	// AIN0
+
+	D111	= P1_11
+	D010	= P0_10	// NFC2
+	D009	= P0_09	// NFC1
+
+	D026	= P0_26
+	D012	= P0_12
+	D101	= P1_01
+	D102	= P1_02
+	D107	= P1_07
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	AIN2	= P0_04	// Battery
+	AIN7	= P0_31
+	AIN5	= P0_29
+	AIN0	= P0_02
+)
+```
+
+Analog Pins
+
+
+```go
+const (
+	LED = P0_15
+)
+```
+
+
+
+```go
+const (
+	UART_RX_PIN	= P0_06
+	UART_TX_PIN	= P0_08
+)
+```
+
+UART0 pins (logical UART1)
+
+
+```go
+const (
+	SDA_PIN	= P0_17	// I2C0 external
+	SCL_PIN	= P0_20	// I2C0 external
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= P0_22	// SCK
+	SPI0_SDO_PIN	= P0_24	// SDO
+	SPI0_SDI_PIN	= P1_00	// SDI
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	P0_00	Pin	= 0
+	P0_01	Pin	= 1
+	P0_02	Pin	= 2
+	P0_03	Pin	= 3
+	P0_04	Pin	= 4
+	P0_05	Pin	= 5
+	P0_06	Pin	= 6
+	P0_07	Pin	= 7
+	P0_08	Pin	= 8
+	P0_09	Pin	= 9
+	P0_10	Pin	= 10
+	P0_11	Pin	= 11
+	P0_12	Pin	= 12
+	P0_13	Pin	= 13
+	P0_14	Pin	= 14
+	P0_15	Pin	= 15
+	P0_16	Pin	= 16
+	P0_17	Pin	= 17
+	P0_18	Pin	= 18
+	P0_19	Pin	= 19
+	P0_20	Pin	= 20
+	P0_21	Pin	= 21
+	P0_22	Pin	= 22
+	P0_23	Pin	= 23
+	P0_24	Pin	= 24
+	P0_25	Pin	= 25
+	P0_26	Pin	= 26
+	P0_27	Pin	= 27
+	P0_28	Pin	= 28
+	P0_29	Pin	= 29
+	P0_30	Pin	= 30
+	P0_31	Pin	= 31
+	P1_00	Pin	= 32
+	P1_01	Pin	= 33
+	P1_02	Pin	= 34
+	P1_03	Pin	= 35
+	P1_04	Pin	= 36
+	P1_05	Pin	= 37
+	P1_06	Pin	= 38
+	P1_07	Pin	= 39
+	P1_08	Pin	= 40
+	P1_09	Pin	= 41
+	P1_10	Pin	= 42
+	P1_11	Pin	= 43
+	P1_12	Pin	= 44
+	P1_13	Pin	= 45
+	P1_14	Pin	= 46
+	P1_15	Pin	= 47
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
+	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
+	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 36h)
+	WatchdogMaxTimeout = (0xffffffff * 1000) / 32768
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	// UART0 is the hardware UART on the NRF SoC.
+	_UART0	= UART{Buffer: NewRingBuffer()}
+	UART0	= &_UART0
+)
+```
+
+UART
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	PWM0	= &PWM{PWM: nrf.PWM0}
+	PWM1	= &PWM{PWM: nrf.PWM1}
+	PWM2	= &PWM{PWM: nrf.PWM2}
+	PWM3	= &PWM{PWM: nrf.PWM3}
+)
+```
+
+PWM
+
+
+```go
+var (
+	I2C0	= &I2C{Bus: nrf.TWIM0, BusT: nrf.TWIS0}
+	I2C1	= &I2C{Bus: nrf.TWIM1, BusT: nrf.TWIS1}
+)
+```
+
+There are 2 I2C interfaces on the NRF.
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	SPI0	= &SPI{Bus: nrf.SPIM0, buf: new([1]byte)}
+	SPI1	= &SPI{Bus: nrf.SPIM1, buf: new([1]byte)}
+	SPI2	= &SPI{Bus: nrf.SPIM2, buf: new([1]byte)}
+)
+```
+
+There are 3 SPI interfaces on the NRF528xx.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader resets the chip into the UF2 bootloader. After reset, it
+can be flashed via nrfutil or by copying a UF2 file to the mass storage device
+
+
+### func EnterOTABootloader
+
+```go
+func EnterOTABootloader()
+```
+
+EnterOTABootloader resets the chip into the bootloader so that it can be
+flashed via an OTA update
+
+
+### func EnterSerialBootloader
+
+```go
+func EnterSerialBootloader()
+```
+
+EnterSerialBootloader resets the chip into the serial bootloader. After
+reset, it can be flashed using serial/nrfutil.
+
+
+### func EnterUF2Bootloader
+
+```go
+func EnterUF2Bootloader()
+```
+
+EnterUF2Bootloader resets the chip into the UF2 bootloader. After reset, it
+can be flashed via nrfutil or by copying a UF2 file to the mass storage device
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (ret uint32, err error)
+```
+
+GetRNG returns 32 bits of non-deterministic random data based on internal thermal noise.
+According to Nordic's documentation, the random output is suitable for cryptographic purposes.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() int32
+```
+
+ReadTemperature reads the silicon die temperature of the chip. The return
+value is in milli-celsius.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USBHID (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (*ADC) Configure
+
+```go
+func (a *ADC) Configure(config ADCConfig)
+```
+
+Configure configures an ADC pin to be able to read analog data.
+Reference voltage can be 150, 300, 600, 1200, 1800, 2400, 3000(default), 3600 mV
+Resolution can be 8, 10, 12(default), 14 bits
+SampleTime will be ceiled to 3(default), 5, 10, 15, 20 or 40(max) µS respectively
+Samples can be 1(default), 2, 4, 8, 16, 32, 64, 128, 256 samples
+
+
+### func (*ADC) Get
+
+```go
+func (a *ADC) Get() uint16
+```
+
+Get returns the current value of an ADC pin in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*nrf.TWIM_Type	// Called Bus to align with Bus field in nrf51
+	BusT	*nrf.TWIS_Type
+	mode	I2CMode
+}
+```
+
+I2C on the NRF528xx.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint8) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+Reply supplies the response data the controller.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) (err error)
+```
+
+Tx does a single I2C transaction at the specified address (when in controller mode).
+
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+WaitForEvent blocks the current go-routine until an I2C event is received (when in Target mode).
+
+The passed buffer will be populated for receive events, with the number of bytes
+received returned in count.  For other event types, buf is not modified and a count
+of zero is returned.
+
+For request events, the caller MUST call `Reply` to avoid hanging the i2c bus indefinitely.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDM
+
+```go
+type PDM struct {
+	device		*nrf.PDM_Type
+	defaultBuffer	int16
+}
+```
+
+PDM represents a PDM device
+
+
+
+### func (*PDM) Configure
+
+```go
+func (pdm *PDM) Configure(config PDMConfig) error
+```
+
+Configure is intended to set up the PDM interface prior to use.
+
+
+### func (*PDM) Read
+
+```go
+func (pdm *PDM) Read(buf []int16) (uint32, error)
+```
+
+Read stores a set of samples in the given target buffer.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWM
+
+```go
+type PWM struct {
+	PWM	*nrf.PWM_Type
+
+	channelValues	[4]volatile.Register16
+}
+```
+
+PWM is one PWM peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this PWM peripheral at
+once.
+
+
+
+### func (*PWM) Channel
+
+```go
+func (pwm *PWM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*PWM) Configure
+
+```go
+func (pwm *PWM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+On the nRF52 series, the maximum period is around 0.26s.
+
+
+### func (*PWM) Set
+
+```go
+func (pwm *PWM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	ch.Set(ch.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*PWM) SetInverting
+
+```go
+func (pwm *PWM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*PWM) SetPeriod
+
+```go
+func (pwm *PWM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*PWM) Top
+
+```go
+func (pwm *PWM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*nrf.SPIM_Type
+	buf	*[1]byte	// 1-byte buffer for the Transfer method
+}
+```
+
+SPI on the NRF.
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to set up the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous
+write/read interface, there must always be the same number of bytes written
+as bytes read. Therefore, if the number of bytes don't match it will be
+padded until they fit: if len(w) > len(r) the extra bytes received will be
+dropped and if len(w) < len(r) extra 0 bytes will be sent.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer *RingBuffer
+}
+```
+
+UART on the NRF.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/nodemcu.md b/content/docs/reference/microcontrollers/machine/nodemcu.md
new file mode 100644
index 00000000..3ddc6eef
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/nodemcu.md
@@ -0,0 +1,637 @@
+
+---
+title: nodemcu
+---
+
+
+## Constants
+
+```go
+const (
+	D0	= GPIO16
+	D1	= GPIO5
+	D2	= GPIO4
+	D3	= GPIO0
+	D4	= GPIO2
+	D5	= GPIO14
+	D6	= GPIO12
+	D7	= GPIO13
+	D8	= GPIO15
+)
+```
+
+GPIO pins on the NodeMCU board.
+
+
+```go
+const LED = D4
+```
+
+Onboard blue LED (on the AI-Thinker module).
+
+
+```go
+const (
+	SPI0_SCK_PIN	= D5
+	SPI0_SDO_PIN	= D7
+	SPI0_SDI_PIN	= D6
+	SPI0_CS0_PIN	= D8
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	SDA_PIN	= D2
+	SCL_PIN	= D1
+)
+```
+
+I2C pins
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinOutput	PinMode	= iota
+	PinInput
+)
+```
+
+
+
+```go
+const (
+	GPIO0	Pin	= iota
+	GPIO1
+	GPIO2
+	GPIO3
+	GPIO4
+	GPIO5
+	GPIO6
+	GPIO7
+	GPIO8
+	GPIO9
+	GPIO10
+	GPIO11
+	GPIO12
+	GPIO13
+	GPIO14
+	GPIO15
+	GPIO16
+)
+```
+
+Hardware pin numbers
+
+
+```go
+const (
+	UART_TX_PIN	Pin	= 1
+	UART_RX_PIN	Pin	= 3
+)
+```
+
+Pins that are fixed by the chip.
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var UART0 = &_UART0
+```
+
+UART0 is a hardware UART that supports both TX and RX.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure sets the given pin as output or input pin.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+Warning: only use this on an output pin!
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+Warning: only use this on an output pin!
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set sets the output value of this pin to high (true) or low (false).
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer *RingBuffer
+}
+```
+
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART baud rate. TX and RX pins are fixed by the hardware so
+cannot be modified and will be ignored.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/nrf52840-mdk-usb-dongle.md b/content/docs/reference/microcontrollers/machine/nrf52840-mdk-usb-dongle.md
new file mode 100644
index 00000000..dff88cd6
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/nrf52840-mdk-usb-dongle.md
@@ -0,0 +1,1498 @@
+
+---
+title: nrf52840-mdk-usb-dongle
+---
+
+
+## Constants
+
+```go
+const HasLowFrequencyCrystal = true
+```
+
+
+
+```go
+const (
+	LED		Pin	= LED_GREEN
+	LED_GREEN	Pin	= 22
+	LED_RED		Pin	= 23
+	LED_BLUE	Pin	= 24
+)
+```
+
+LEDs on the nrf52840-mdk-usb-dongle
+
+
+```go
+const (
+	BUTTON Pin = 18
+)
+```
+
+RESET/USR button, depending on value of PSELRESET UICR register
+
+
+```go
+const (
+	UART_TX_PIN	Pin	= NoPin
+	UART_RX_PIN	Pin	= NoPin
+)
+```
+
+UART pins
+
+
+```go
+const (
+	SDA_PIN	= NoPin
+	SCL_PIN	= NoPin
+)
+```
+
+I2C pins (unused)
+
+
+```go
+const (
+	SPI0_SCK_PIN	= NoPin
+	SPI0_SDO_PIN	= NoPin
+	SPI0_SDI_PIN	= NoPin
+)
+```
+
+SPI pins (unused)
+
+
+```go
+const (
+	P0_00	Pin	= 0
+	P0_01	Pin	= 1
+	P0_02	Pin	= 2
+	P0_03	Pin	= 3
+	P0_04	Pin	= 4
+	P0_05	Pin	= 5
+	P0_06	Pin	= 6
+	P0_07	Pin	= 7
+	P0_08	Pin	= 8
+	P0_09	Pin	= 9
+	P0_10	Pin	= 10
+	P0_11	Pin	= 11
+	P0_12	Pin	= 12
+	P0_13	Pin	= 13
+	P0_14	Pin	= 14
+	P0_15	Pin	= 15
+	P0_16	Pin	= 16
+	P0_17	Pin	= 17
+	P0_18	Pin	= 18
+	P0_19	Pin	= 19
+	P0_20	Pin	= 20
+	P0_21	Pin	= 21
+	P0_22	Pin	= 22
+	P0_23	Pin	= 23
+	P0_24	Pin	= 24
+	P0_25	Pin	= 25
+	P0_26	Pin	= 26
+	P0_27	Pin	= 27
+	P0_28	Pin	= 28
+	P0_29	Pin	= 29
+	P0_30	Pin	= 30
+	P0_31	Pin	= 31
+	P1_00	Pin	= 32
+	P1_01	Pin	= 33
+	P1_02	Pin	= 34
+	P1_03	Pin	= 35
+	P1_04	Pin	= 36
+	P1_05	Pin	= 37
+	P1_06	Pin	= 38
+	P1_07	Pin	= 39
+	P1_08	Pin	= 40
+	P1_09	Pin	= 41
+	P1_10	Pin	= 42
+	P1_11	Pin	= 43
+	P1_12	Pin	= 44
+	P1_13	Pin	= 45
+	P1_14	Pin	= 46
+	P1_15	Pin	= 47
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
+	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
+	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 36h)
+	WatchdogMaxTimeout = (0xffffffff * 1000) / 32768
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	// UART0 is the hardware UART on the NRF SoC.
+	_UART0	= UART{Buffer: NewRingBuffer()}
+	UART0	= &_UART0
+)
+```
+
+UART
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	PWM0	= &PWM{PWM: nrf.PWM0}
+	PWM1	= &PWM{PWM: nrf.PWM1}
+	PWM2	= &PWM{PWM: nrf.PWM2}
+	PWM3	= &PWM{PWM: nrf.PWM3}
+)
+```
+
+PWM
+
+
+```go
+var (
+	I2C0	= &I2C{Bus: nrf.TWIM0, BusT: nrf.TWIS0}
+	I2C1	= &I2C{Bus: nrf.TWIM1, BusT: nrf.TWIS1}
+)
+```
+
+There are 2 I2C interfaces on the NRF.
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	SPI0	= &SPI{Bus: nrf.SPIM0, buf: new([1]byte)}
+	SPI1	= &SPI{Bus: nrf.SPIM1, buf: new([1]byte)}
+	SPI2	= &SPI{Bus: nrf.SPIM2, buf: new([1]byte)}
+)
+```
+
+There are 3 SPI interfaces on the NRF528xx.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader resets the chip into the UF2 bootloader. After reset, it
+can be flashed via nrfutil or by copying a UF2 file to the mass storage device
+
+
+### func EnterOTABootloader
+
+```go
+func EnterOTABootloader()
+```
+
+EnterOTABootloader resets the chip into the bootloader so that it can be
+flashed via an OTA update
+
+
+### func EnterSerialBootloader
+
+```go
+func EnterSerialBootloader()
+```
+
+EnterSerialBootloader resets the chip into the serial bootloader. After
+reset, it can be flashed using serial/nrfutil.
+
+
+### func EnterUF2Bootloader
+
+```go
+func EnterUF2Bootloader()
+```
+
+EnterUF2Bootloader resets the chip into the UF2 bootloader. After reset, it
+can be flashed via nrfutil or by copying a UF2 file to the mass storage device
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (ret uint32, err error)
+```
+
+GetRNG returns 32 bits of non-deterministic random data based on internal thermal noise.
+According to Nordic's documentation, the random output is suitable for cryptographic purposes.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() int32
+```
+
+ReadTemperature reads the silicon die temperature of the chip. The return
+value is in milli-celsius.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USBHID (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (*ADC) Configure
+
+```go
+func (a *ADC) Configure(config ADCConfig)
+```
+
+Configure configures an ADC pin to be able to read analog data.
+Reference voltage can be 150, 300, 600, 1200, 1800, 2400, 3000(default), 3600 mV
+Resolution can be 8, 10, 12(default), 14 bits
+SampleTime will be ceiled to 3(default), 5, 10, 15, 20 or 40(max) µS respectively
+Samples can be 1(default), 2, 4, 8, 16, 32, 64, 128, 256 samples
+
+
+### func (*ADC) Get
+
+```go
+func (a *ADC) Get() uint16
+```
+
+Get returns the current value of an ADC pin in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*nrf.TWIM_Type	// Called Bus to align with Bus field in nrf51
+	BusT	*nrf.TWIS_Type
+	mode	I2CMode
+}
+```
+
+I2C on the NRF528xx.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint8) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+Reply supplies the response data the controller.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) (err error)
+```
+
+Tx does a single I2C transaction at the specified address (when in controller mode).
+
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+WaitForEvent blocks the current go-routine until an I2C event is received (when in Target mode).
+
+The passed buffer will be populated for receive events, with the number of bytes
+received returned in count.  For other event types, buf is not modified and a count
+of zero is returned.
+
+For request events, the caller MUST call `Reply` to avoid hanging the i2c bus indefinitely.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDM
+
+```go
+type PDM struct {
+	device		*nrf.PDM_Type
+	defaultBuffer	int16
+}
+```
+
+PDM represents a PDM device
+
+
+
+### func (*PDM) Configure
+
+```go
+func (pdm *PDM) Configure(config PDMConfig) error
+```
+
+Configure is intended to set up the PDM interface prior to use.
+
+
+### func (*PDM) Read
+
+```go
+func (pdm *PDM) Read(buf []int16) (uint32, error)
+```
+
+Read stores a set of samples in the given target buffer.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWM
+
+```go
+type PWM struct {
+	PWM	*nrf.PWM_Type
+
+	channelValues	[4]volatile.Register16
+}
+```
+
+PWM is one PWM peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this PWM peripheral at
+once.
+
+
+
+### func (*PWM) Channel
+
+```go
+func (pwm *PWM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*PWM) Configure
+
+```go
+func (pwm *PWM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+On the nRF52 series, the maximum period is around 0.26s.
+
+
+### func (*PWM) Set
+
+```go
+func (pwm *PWM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	ch.Set(ch.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*PWM) SetInverting
+
+```go
+func (pwm *PWM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*PWM) SetPeriod
+
+```go
+func (pwm *PWM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*PWM) Top
+
+```go
+func (pwm *PWM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*nrf.SPIM_Type
+	buf	*[1]byte	// 1-byte buffer for the Transfer method
+}
+```
+
+SPI on the NRF.
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to set up the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous
+write/read interface, there must always be the same number of bytes written
+as bytes read. Therefore, if the number of bytes don't match it will be
+padded until they fit: if len(w) > len(r) the extra bytes received will be
+dropped and if len(w) < len(r) extra 0 bytes will be sent.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer *RingBuffer
+}
+```
+
+UART on the NRF.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/nrf52840-mdk.md b/content/docs/reference/microcontrollers/machine/nrf52840-mdk.md
new file mode 100644
index 00000000..cc59e344
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/nrf52840-mdk.md
@@ -0,0 +1,1488 @@
+
+---
+title: nrf52840-mdk
+---
+
+
+## Constants
+
+```go
+const HasLowFrequencyCrystal = true
+```
+
+
+
+```go
+const (
+	LED_GREEN	Pin	= 22
+	LED_RED		Pin	= 23
+	LED_BLUE	Pin	= 24
+	LED		Pin	= LED_GREEN
+)
+```
+
+LEDs on the nrf52840-mdk (nRF52840 dev board)
+
+
+```go
+const (
+	UART_TX_PIN	Pin	= 20
+	UART_RX_PIN	Pin	= 19
+)
+```
+
+UART pins
+
+
+```go
+const (
+	SDA_PIN	= NoPin
+	SCL_PIN	= NoPin
+)
+```
+
+I2C pins (unused)
+
+
+```go
+const (
+	SPI0_SCK_PIN	= NoPin
+	SPI0_SDO_PIN	= NoPin
+	SPI0_SDI_PIN	= NoPin
+)
+```
+
+SPI pins (unused)
+
+
+```go
+const (
+	P0_00	Pin	= 0
+	P0_01	Pin	= 1
+	P0_02	Pin	= 2
+	P0_03	Pin	= 3
+	P0_04	Pin	= 4
+	P0_05	Pin	= 5
+	P0_06	Pin	= 6
+	P0_07	Pin	= 7
+	P0_08	Pin	= 8
+	P0_09	Pin	= 9
+	P0_10	Pin	= 10
+	P0_11	Pin	= 11
+	P0_12	Pin	= 12
+	P0_13	Pin	= 13
+	P0_14	Pin	= 14
+	P0_15	Pin	= 15
+	P0_16	Pin	= 16
+	P0_17	Pin	= 17
+	P0_18	Pin	= 18
+	P0_19	Pin	= 19
+	P0_20	Pin	= 20
+	P0_21	Pin	= 21
+	P0_22	Pin	= 22
+	P0_23	Pin	= 23
+	P0_24	Pin	= 24
+	P0_25	Pin	= 25
+	P0_26	Pin	= 26
+	P0_27	Pin	= 27
+	P0_28	Pin	= 28
+	P0_29	Pin	= 29
+	P0_30	Pin	= 30
+	P0_31	Pin	= 31
+	P1_00	Pin	= 32
+	P1_01	Pin	= 33
+	P1_02	Pin	= 34
+	P1_03	Pin	= 35
+	P1_04	Pin	= 36
+	P1_05	Pin	= 37
+	P1_06	Pin	= 38
+	P1_07	Pin	= 39
+	P1_08	Pin	= 40
+	P1_09	Pin	= 41
+	P1_10	Pin	= 42
+	P1_11	Pin	= 43
+	P1_12	Pin	= 44
+	P1_13	Pin	= 45
+	P1_14	Pin	= 46
+	P1_15	Pin	= 47
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
+	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
+	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 36h)
+	WatchdogMaxTimeout = (0xffffffff * 1000) / 32768
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	// UART0 is the hardware UART on the NRF SoC.
+	_UART0	= UART{Buffer: NewRingBuffer()}
+	UART0	= &_UART0
+)
+```
+
+UART
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	PWM0	= &PWM{PWM: nrf.PWM0}
+	PWM1	= &PWM{PWM: nrf.PWM1}
+	PWM2	= &PWM{PWM: nrf.PWM2}
+	PWM3	= &PWM{PWM: nrf.PWM3}
+)
+```
+
+PWM
+
+
+```go
+var (
+	I2C0	= &I2C{Bus: nrf.TWIM0, BusT: nrf.TWIS0}
+	I2C1	= &I2C{Bus: nrf.TWIM1, BusT: nrf.TWIS1}
+)
+```
+
+There are 2 I2C interfaces on the NRF.
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	SPI0	= &SPI{Bus: nrf.SPIM0, buf: new([1]byte)}
+	SPI1	= &SPI{Bus: nrf.SPIM1, buf: new([1]byte)}
+	SPI2	= &SPI{Bus: nrf.SPIM2, buf: new([1]byte)}
+)
+```
+
+There are 3 SPI interfaces on the NRF528xx.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader resets the chip into the serial bootloader.
+
+
+### func EnterOTABootloader
+
+```go
+func EnterOTABootloader()
+```
+
+EnterOTABootloader resets the chip into the bootloader so that it can be
+flashed via an OTA update
+
+
+### func EnterSerialBootloader
+
+```go
+func EnterSerialBootloader()
+```
+
+EnterSerialBootloader resets the chip into the serial bootloader. After
+reset, it can be flashed using serial/nrfutil.
+
+
+### func EnterUF2Bootloader
+
+```go
+func EnterUF2Bootloader()
+```
+
+EnterUF2Bootloader resets the chip into the UF2 bootloader. After reset, it
+can be flashed via nrfutil or by copying a UF2 file to the mass storage device
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (ret uint32, err error)
+```
+
+GetRNG returns 32 bits of non-deterministic random data based on internal thermal noise.
+According to Nordic's documentation, the random output is suitable for cryptographic purposes.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() int32
+```
+
+ReadTemperature reads the silicon die temperature of the chip. The return
+value is in milli-celsius.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USBHID (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (*ADC) Configure
+
+```go
+func (a *ADC) Configure(config ADCConfig)
+```
+
+Configure configures an ADC pin to be able to read analog data.
+Reference voltage can be 150, 300, 600, 1200, 1800, 2400, 3000(default), 3600 mV
+Resolution can be 8, 10, 12(default), 14 bits
+SampleTime will be ceiled to 3(default), 5, 10, 15, 20 or 40(max) µS respectively
+Samples can be 1(default), 2, 4, 8, 16, 32, 64, 128, 256 samples
+
+
+### func (*ADC) Get
+
+```go
+func (a *ADC) Get() uint16
+```
+
+Get returns the current value of an ADC pin in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*nrf.TWIM_Type	// Called Bus to align with Bus field in nrf51
+	BusT	*nrf.TWIS_Type
+	mode	I2CMode
+}
+```
+
+I2C on the NRF528xx.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint8) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+Reply supplies the response data the controller.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) (err error)
+```
+
+Tx does a single I2C transaction at the specified address (when in controller mode).
+
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+WaitForEvent blocks the current go-routine until an I2C event is received (when in Target mode).
+
+The passed buffer will be populated for receive events, with the number of bytes
+received returned in count.  For other event types, buf is not modified and a count
+of zero is returned.
+
+For request events, the caller MUST call `Reply` to avoid hanging the i2c bus indefinitely.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDM
+
+```go
+type PDM struct {
+	device		*nrf.PDM_Type
+	defaultBuffer	int16
+}
+```
+
+PDM represents a PDM device
+
+
+
+### func (*PDM) Configure
+
+```go
+func (pdm *PDM) Configure(config PDMConfig) error
+```
+
+Configure is intended to set up the PDM interface prior to use.
+
+
+### func (*PDM) Read
+
+```go
+func (pdm *PDM) Read(buf []int16) (uint32, error)
+```
+
+Read stores a set of samples in the given target buffer.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWM
+
+```go
+type PWM struct {
+	PWM	*nrf.PWM_Type
+
+	channelValues	[4]volatile.Register16
+}
+```
+
+PWM is one PWM peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this PWM peripheral at
+once.
+
+
+
+### func (*PWM) Channel
+
+```go
+func (pwm *PWM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*PWM) Configure
+
+```go
+func (pwm *PWM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+On the nRF52 series, the maximum period is around 0.26s.
+
+
+### func (*PWM) Set
+
+```go
+func (pwm *PWM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	ch.Set(ch.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*PWM) SetInverting
+
+```go
+func (pwm *PWM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*PWM) SetPeriod
+
+```go
+func (pwm *PWM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*PWM) Top
+
+```go
+func (pwm *PWM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*nrf.SPIM_Type
+	buf	*[1]byte	// 1-byte buffer for the Transfer method
+}
+```
+
+SPI on the NRF.
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to set up the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous
+write/read interface, there must always be the same number of bytes written
+as bytes read. Therefore, if the number of bytes don't match it will be
+padded until they fit: if len(w) > len(r) the extra bytes received will be
+dropped and if len(w) < len(r) extra 0 bytes will be sent.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer *RingBuffer
+}
+```
+
+UART on the NRF.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/nucleo-f103rb.md b/content/docs/reference/microcontrollers/machine/nucleo-f103rb.md
new file mode 100644
index 00000000..ad924760
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/nucleo-f103rb.md
@@ -0,0 +1,1593 @@
+
+---
+title: nucleo-f103rb
+---
+
+
+## Constants
+
+```go
+const (
+	LED		= LED_BUILTIN
+	LED_BUILTIN	= LED_GREEN
+	LED_GREEN	= PA5
+)
+```
+
+
+
+```go
+const (
+	BUTTON		= BUTTON_USER
+	BUTTON_USER	= PC13
+)
+```
+
+
+
+```go
+const (
+	UART_TX_PIN	= PA2
+	UART_RX_PIN	= PA3
+	UART_ALT_TX_PIN	= PD5
+	UART_ALT_RX_PIN	= PD6
+)
+```
+
+UART pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= PA5
+	SPI0_SDI_PIN	= PA6
+	SPI0_SDO_PIN	= PA7
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	I2C0_SCL_PIN	= PB6
+	I2C0_SDA_PIN	= PB7
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinRising	PinChange	= 1 << iota
+	PinFalling
+	PinToggle	= PinRising | PinFalling
+)
+```
+
+
+
+```go
+const (
+	Cycles_1_5	= 0x0
+	Cycles_7_5	= 0x1
+	Cycles_13_5	= 0x2
+	Cycles_28_5	= 0x3
+	Cycles_41_5	= 0x4
+	Cycles_55_5	= 0x5
+	Cycles_71_5	= 0x6
+	Cycles_239_5	= 0x7
+)
+```
+
+
+
+```go
+const (
+	DutyCycle2	= 0
+	DutyCycle16x9	= 1
+)
+```
+
+I2C fast mode (Fm) duty cycle
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (32.768s)
+	//
+	// Timeout is based on 12-bit counter with /256 divider on
+	// 32.768kHz clock.  See 21.3.3 of RM0090 for table.
+	WatchdogMaxTimeout = ((0xfff + 1) * 256 * 1024) / 32768
+)
+```
+
+
+
+```go
+const PWM_MODE1 = 0x6
+```
+
+
+
+```go
+const APB1_TIM_FREQ = 72e6	// 72MHz
+
+```
+
+Internal use: configured speed of the APB1 and APB2 timers, this should be kept
+in sync with any changes to runtime package which configures the oscillators
+and clock frequencies
+
+
+```go
+const APB2_TIM_FREQ = 72e6	// 72MHz
+
+```
+
+
+
+```go
+const (
+	PinInput	PinMode	= 0	// Input mode
+	PinOutput10MHz	PinMode	= 1	// Output mode, max speed 10MHz
+	PinOutput2MHz	PinMode	= 2	// Output mode, max speed 2MHz
+	PinOutput50MHz	PinMode	= 3	// Output mode, max speed 50MHz
+	PinOutput	PinMode	= PinOutput2MHz
+
+	PinInputModeAnalog	PinMode	= 0	// Input analog mode
+	PinInputModeFloating	PinMode	= 4	// Input floating mode
+	PinInputModePullUpDown	PinMode	= 8	// Input pull up/down mode
+	PinInputModeReserved	PinMode	= 12	// Input mode (reserved)
+
+	PinOutputModeGPPushPull		PinMode	= 0	// Output mode general purpose push/pull
+	PinOutputModeGPOpenDrain	PinMode	= 4	// Output mode general purpose open drain
+	PinOutputModeAltPushPull	PinMode	= 8	// Output mode alt. purpose push/pull
+	PinOutputModeAltOpenDrain	PinMode	= 12	// Output mode alt. purpose open drain
+
+	// Pull-up vs Pull down is not part of the CNF0 / CNF1 bits, but is
+	// controlled by PxODR.  Encoded using the 'spare' bit 5.
+	PinInputPulldown	PinMode	= PinInputModePullUpDown
+	PinInputPullup		PinMode	= PinInputModePullUpDown | 0x10
+)
+```
+
+
+
+```go
+const (
+	PA0	= portA + 0
+	PA1	= portA + 1
+	PA2	= portA + 2
+	PA3	= portA + 3
+	PA4	= portA + 4
+	PA5	= portA + 5
+	PA6	= portA + 6
+	PA7	= portA + 7
+	PA8	= portA + 8
+	PA9	= portA + 9
+	PA10	= portA + 10
+	PA11	= portA + 11
+	PA12	= portA + 12
+	PA13	= portA + 13
+	PA14	= portA + 14
+	PA15	= portA + 15
+
+	PB0	= portB + 0
+	PB1	= portB + 1
+	PB2	= portB + 2
+	PB3	= portB + 3
+	PB4	= portB + 4
+	PB5	= portB + 5
+	PB6	= portB + 6
+	PB7	= portB + 7
+	PB8	= portB + 8
+	PB9	= portB + 9
+	PB10	= portB + 10
+	PB11	= portB + 11
+	PB12	= portB + 12
+	PB13	= portB + 13
+	PB14	= portB + 14
+	PB15	= portB + 15
+
+	PC0	= portC + 0
+	PC1	= portC + 1
+	PC2	= portC + 2
+	PC3	= portC + 3
+	PC4	= portC + 4
+	PC5	= portC + 5
+	PC6	= portC + 6
+	PC7	= portC + 7
+	PC8	= portC + 8
+	PC9	= portC + 9
+	PC10	= portC + 10
+	PC11	= portC + 11
+	PC12	= portC + 12
+	PC13	= portC + 13
+	PC14	= portC + 14
+	PC15	= portC + 15
+
+	PD0	= portD + 0
+	PD1	= portD + 1
+	PD2	= portD + 2
+	PD3	= portD + 3
+	PD4	= portD + 4
+	PD5	= portD + 5
+	PD6	= portD + 6
+	PD7	= portD + 7
+	PD8	= portD + 8
+	PD9	= portD + 9
+	PD10	= portD + 10
+	PD11	= portD + 11
+	PD12	= portD + 12
+	PD13	= portD + 13
+	PD14	= portD + 14
+	PD15	= portD + 15
+
+	PE0	= portE + 0
+	PE1	= portE + 1
+	PE2	= portE + 2
+	PE3	= portE + 3
+	PE4	= portE + 4
+	PE5	= portE + 5
+	PE6	= portE + 6
+	PE7	= portE + 7
+	PE8	= portE + 8
+	PE9	= portE + 9
+	PE10	= portE + 10
+	PE11	= portE + 11
+	PE12	= portE + 12
+	PE13	= portE + 13
+	PE14	= portE + 14
+	PE15	= portE + 15
+
+	PF0	= portF + 0
+	PF1	= portF + 1
+	PF2	= portF + 2
+	PF3	= portF + 3
+	PF4	= portF + 4
+	PF5	= portF + 5
+	PF6	= portF + 6
+	PF7	= portF + 7
+	PF8	= portF + 8
+	PF9	= portF + 9
+	PF10	= portF + 10
+	PF11	= portF + 11
+	PF12	= portF + 12
+	PF13	= portF + 13
+	PF14	= portF + 14
+	PF15	= portF + 15
+)
+```
+
+Pin constants for all stm32f103 package sizes
+
+
+```go
+const (
+	ARR_MAX	= 0x10000
+	PSC_MAX	= 0x10000
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	// USART2 is the hardware serial port connected to the onboard ST-LINK
+	// debugger to be exposed as virtual COM port over USB on Nucleo boards.
+	UART2	= &_UART2
+	_UART2	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	stm32.USART2,
+	}
+	DefaultUART	= UART2
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	SPI1	= &SPI{Bus: stm32.SPI1}
+	SPI0	= SPI1
+)
+```
+
+There are 3 SPI interfaces on the STM32F103xx.
+Since the first interface is named SPI1, both SPI0 and SPI1 refer to SPI1.
+TODO: implement SPI2 and SPI3.
+
+
+```go
+var (
+	I2C1	= &I2C{Bus: stm32.I2C1}
+	I2C0	= I2C1
+)
+```
+
+
+
+```go
+var (
+	TIM1	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM1EN,
+		Device:		stm32.TIM1,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PE9, 0b11}, {PA8, 0b00}}},
+			TimerChannel{Pins: []PinFunction{{PE11, 0b11}, {PA9, 0b00}}},
+			TimerChannel{Pins: []PinFunction{{PE13, 0b11}, {PA10, 0b00}}},
+			TimerChannel{Pins: []PinFunction{{PE14, 0b11}, {PA11, 0b00}}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM2	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM2EN,
+		Device:		stm32.TIM2,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA0, 0b00}, {PA15, 0b01}}},
+			TimerChannel{Pins: []PinFunction{{PA1, 0b00}, {PB3, 0b01}}},
+			TimerChannel{Pins: []PinFunction{{PA2, 0b00}, {PB10, 0b10}}},
+			TimerChannel{Pins: []PinFunction{{PA3, 0b00}, {PB11, 0b10}}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM3	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM3EN,
+		Device:		stm32.TIM3,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA6, 0b00}, {PC6, 0b11}, {PB4, 0b10}}},
+			TimerChannel{Pins: []PinFunction{{PA7, 0b00}, {PC7, 0b11}, {PB5, 0b10}}},
+			TimerChannel{Pins: []PinFunction{{PB0, 0b00}, {PC8, 0b11}}},
+			TimerChannel{Pins: []PinFunction{{PB1, 0b00}, {PC9, 0b11}}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM4	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM4EN,
+		Device:		stm32.TIM4,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PD12, 0b1}, {PB6, 0}}},
+			TimerChannel{Pins: []PinFunction{{PD13, 0b1}, {PB7, 0}}},
+			TimerChannel{Pins: []PinFunction{{PD14, 0b1}, {PB8, 0}}},
+			TimerChannel{Pins: []PinFunction{{PD15, 0b1}, {PB9, 0}}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM5	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM5EN,
+		Device:		stm32.TIM5,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{{PA3, 0b0}}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM6	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM6EN,
+		Device:		stm32.TIM6,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM7	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM7EN,
+		Device:		stm32.TIM7,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM8	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM8EN,
+		Device:		stm32.TIM8,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM9	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM9EN,
+		Device:		stm32.TIM9,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA2, 0b0}, {PE5, 0b1}}},
+			TimerChannel{Pins: []PinFunction{{PA3, 0b0}, {PE6, 0b1}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM10	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM10EN,
+		Device:		stm32.TIM10,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PB8, 0b0}, {PF6, 0b1}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM11	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM11EN,
+		Device:		stm32.TIM11,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PB9, 0b0}, {PF7, 0b1}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM12	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM12EN,
+		Device:		stm32.TIM12,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM13	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM13EN,
+		Device:		stm32.TIM13,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA6, 0b0}, {PF8, 0b1}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM14	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM14EN,
+		Device:		stm32.TIM14,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA7, 0b0}, {PF9, 0b1}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+)
+```
+
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself.
+
+The length of the device ID for STM32 is 12 bytes (96 bits).
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC1.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(ADCConfig)
+```
+
+Configure configures an ADC pin to be able to read analog data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin in the range 0..0xffff.
+TODO: DMA based implementation.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type ChannelCallback
+
+```go
+type ChannelCallback func(channel uint8)
+```
+
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus *stm32.I2C_Type
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the STM32 I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+	DutyCycle	uint8
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given I/O settings.
+stm32f1xx uses different technique for setting the GPIO pins than the stm32f407
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+PortMaskClear returns the register and mask to disable a given port. This can
+be used to implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+PortMaskSet returns the register and mask to enable a given GPIO pin. This
+can be used to implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+---------- General pin operations ----------
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinFunction
+
+```go
+type PinFunction struct {
+	Pin	Pin
+	AltFunc	uint8
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus *stm32.SPI_Type
+}
+```
+
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the STM32 SPI1 interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type TIM
+
+```go
+type TIM struct {
+	EnableRegister	*volatile.Register32
+	EnableFlag	uint32
+	Device		*stm32.TIM_Type
+	Channels	[4]TimerChannel
+	UpInterrupt	interrupt.Interrupt
+	OCInterrupt	interrupt.Interrupt
+
+	wraparoundCallback	TimerCallback
+	channelCallbacks	[4]ChannelCallback
+
+	busFreq	uint64
+}
+```
+
+
+
+
+### func (*TIM) Channel
+
+```go
+func (t *TIM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*TIM) Configure
+
+```go
+func (t *TIM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+
+
+### func (*TIM) Count
+
+```go
+func (t *TIM) Count() uint32
+```
+
+
+
+### func (*TIM) Set
+
+```go
+func (t *TIM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	t.Set(ch, t.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*TIM) SetInverting
+
+```go
+func (t *TIM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TIM) SetMatchInterrupt
+
+```go
+func (t *TIM) SetMatchInterrupt(channel uint8, callback ChannelCallback) error
+```
+
+Sets a callback to be called when a channel reaches it's set-point.
+
+For example, if `t.Set(ch, t.Top() / 4)` is used then the callback will
+be called every quarter-period of the timer's base Period.
+
+
+### func (*TIM) SetPeriod
+
+```go
+func (t *TIM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TIM) SetWraparoundInterrupt
+
+```go
+func (t *TIM) SetWraparoundInterrupt(callback TimerCallback) error
+```
+
+SetWraparoundInterrupt configures a callback to be called each
+time the timer 'wraps-around'.
+
+For example, if `Configure(PWMConfig{Period:1000000})` is used,
+to set the timer period to 1ms, this callback will be called every
+1ms.
+
+
+### func (*TIM) Top
+
+```go
+func (t *TIM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+### func (*TIM) Unset
+
+```go
+func (t *TIM) Unset(channel uint8)
+```
+
+Unset disables a channel, including any configured interrupts.
+
+
+
+
+## type TimerCallback
+
+```go
+type TimerCallback func()
+```
+
+
+
+
+
+
+## type TimerChannel
+
+```go
+type TimerChannel struct {
+	Pins []PinFunction
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer			*RingBuffer
+	Bus			*stm32.USART_Type
+	Interrupt		interrupt.Interrupt
+	TxAltFuncSelector	uint8
+	RxAltFuncSelector	uint8
+
+	// Registers specific to the chip
+	rxReg		*volatile.Register32
+	txReg		*volatile.Register32
+	statusReg	*volatile.Register32
+	txEmptyFlag	uint32
+}
+```
+
+UART representation
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART. Defer to chip-specific
+routines for calculation
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/nucleo-f722ze.md b/content/docs/reference/microcontrollers/machine/nucleo-f722ze.md
new file mode 100644
index 00000000..0201ce01
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/nucleo-f722ze.md
@@ -0,0 +1,1666 @@
+
+---
+title: nucleo-f722ze
+---
+
+
+## Constants
+
+```go
+const (
+	LED		= LED_BUILTIN
+	LED_BUILTIN	= LED_GREEN
+	LED_GREEN	= PB0
+	LED_BLUE	= PB7
+	LED_RED		= PB14
+)
+```
+
+
+
+```go
+const (
+	BUTTON		= BUTTON_USER
+	BUTTON_USER	= PC13
+)
+```
+
+
+
+```go
+const (
+	// PD8 and PD9 are connected to the ST-Link Virtual Com Port (VCP)
+	UART_TX_PIN	= PD8
+	UART_RX_PIN	= PD9
+	UART_ALT_FN	= 7	// GPIO_AF7_UART3
+)
+```
+
+UART pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= PA5
+	SPI0_SDI_PIN	= PA6
+	SPI0_SDO_PIN	= PA7
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	I2C0_SCL_PIN	= PB8
+	I2C0_SDA_PIN	= PB9
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinRising	PinChange	= 1 << iota
+	PinFalling
+	PinToggle	= PinRising | PinFalling
+)
+```
+
+
+
+```go
+const (
+	MAX_NBYTE_SIZE	= 255
+
+	// 100ms delay = 100e6ns / 16ns
+	// In runtime_stm32_timers.go, tick is fixed at 16ns per tick
+	TIMEOUT_TICKS	= 100e6 / 16
+
+	I2C_NO_STARTSTOP		= 0x0
+	I2C_GENERATE_START_WRITE	= 0x80000000 | stm32.I2C_CR2_START
+	I2C_GENERATE_START_READ		= 0x80000000 | stm32.I2C_CR2_START | stm32.I2C_CR2_RD_WRN
+	I2C_GENERATE_STOP		= 0x80000000 | stm32.I2C_CR2_STOP
+)
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (32.768s)
+	//
+	// Timeout is based on 12-bit counter with /256 divider on
+	// 32.768kHz clock.  See 21.3.3 of RM0090 for table.
+	WatchdogMaxTimeout = ((0xfff + 1) * 256 * 1024) / 32768
+)
+```
+
+
+
+```go
+const (
+	// Mode Flag
+	PinOutput		PinMode	= 0
+	PinInput		PinMode	= PinInputFloating
+	PinInputFloating	PinMode	= 1
+	PinInputPulldown	PinMode	= 2
+	PinInputPullup		PinMode	= 3
+
+	// for UART
+	PinModeUARTTX	PinMode	= 4
+	PinModeUARTRX	PinMode	= 5
+
+	// for I2C
+	PinModeI2CSCL	PinMode	= 6
+	PinModeI2CSDA	PinMode	= 7
+
+	// for SPI
+	PinModeSPICLK	PinMode	= 8
+	PinModeSPISDO	PinMode	= 9
+	PinModeSPISDI	PinMode	= 10
+
+	// for analog/ADC
+	PinInputAnalog	PinMode	= 11
+
+	// for PWM
+	PinModePWMOutput	PinMode	= 12
+)
+```
+
+
+
+```go
+const RNG_MAX_READ_RETRIES = 1000
+```
+
+
+
+```go
+const PWM_MODE1 = 0x6
+```
+
+
+
+```go
+const (
+	AF0_SYSTEM					= 0
+	AF1_TIM1_2					= 1
+	AF2_TIM3_4_5					= 2
+	AF3_TIM8_9_10_11_LPTIM1				= 3
+	AF4_I2C1_2_3_USART1				= 4
+	AF5_SPI1_2_3_4_5_I2S1_2_3			= 5
+	AF6_SPI2_3_I2S2_3_SAI1_UART4			= 6
+	AF7_SPI2_3_I2S2_3_USART1_2_3_UART5		= 7
+	AF8_SAI2_USART6_UART4_5_7_8_OTG1_FS		= 8
+	AF9_CAN1_TIM12_13_14_QUADSPI_FMC_OTG2_HS	= 9
+	AF10_SAI2_QUADSPI_SDMMC2_OTG2_HS_OTG1_FS	= 10
+	AF11_SDMMC2					= 11
+	AF12_UART7_FMC_SDMMC1_OTG2_FS			= 12
+	AF15_EVENTOUT					= 15
+)
+```
+
+Alternative peripheral pin functions
+
+
+```go
+const (
+	PA0	= portA + 0
+	PA1	= portA + 1
+	PA2	= portA + 2
+	PA3	= portA + 3
+	PA4	= portA + 4
+	PA5	= portA + 5
+	PA6	= portA + 6
+	PA7	= portA + 7
+	PA8	= portA + 8
+	PA9	= portA + 9
+	PA10	= portA + 10
+	PA11	= portA + 11
+	PA12	= portA + 12
+	PA13	= portA + 13
+	PA14	= portA + 14
+	PA15	= portA + 15
+
+	PB0	= portB + 0
+	PB1	= portB + 1
+	PB2	= portB + 2
+	PB3	= portB + 3
+	PB4	= portB + 4
+	PB5	= portB + 5
+	PB6	= portB + 6
+	PB7	= portB + 7
+	PB8	= portB + 8
+	PB9	= portB + 9
+	PB10	= portB + 10
+	PB11	= portB + 11
+	PB12	= portB + 12
+	PB13	= portB + 13
+	PB14	= portB + 14
+	PB15	= portB + 15
+
+	PC0	= portC + 0
+	PC1	= portC + 1
+	PC2	= portC + 2
+	PC3	= portC + 3
+	PC4	= portC + 4
+	PC5	= portC + 5
+	PC6	= portC + 6
+	PC7	= portC + 7
+	PC8	= portC + 8
+	PC9	= portC + 9
+	PC10	= portC + 10
+	PC11	= portC + 11
+	PC12	= portC + 12
+	PC13	= portC + 13
+	PC14	= portC + 14
+	PC15	= portC + 15
+
+	PD0	= portD + 0
+	PD1	= portD + 1
+	PD2	= portD + 2
+	PD3	= portD + 3
+	PD4	= portD + 4
+	PD5	= portD + 5
+	PD6	= portD + 6
+	PD7	= portD + 7
+	PD8	= portD + 8
+	PD9	= portD + 9
+	PD10	= portD + 10
+	PD11	= portD + 11
+	PD12	= portD + 12
+	PD13	= portD + 13
+	PD14	= portD + 14
+	PD15	= portD + 15
+
+	PE0	= portE + 0
+	PE1	= portE + 1
+	PE2	= portE + 2
+	PE3	= portE + 3
+	PE4	= portE + 4
+	PE5	= portE + 5
+	PE6	= portE + 6
+	PE7	= portE + 7
+	PE8	= portE + 8
+	PE9	= portE + 9
+	PE10	= portE + 10
+	PE11	= portE + 11
+	PE12	= portE + 12
+	PE13	= portE + 13
+	PE14	= portE + 14
+	PE15	= portE + 15
+
+	PF0	= portF + 0
+	PF1	= portF + 1
+	PF2	= portF + 2
+	PF3	= portF + 3
+	PF4	= portF + 4
+	PF5	= portF + 5
+	PF6	= portF + 6
+	PF7	= portF + 7
+	PF8	= portF + 8
+	PF9	= portF + 9
+	PF10	= portF + 10
+	PF11	= portF + 11
+	PF12	= portF + 12
+	PF13	= portF + 13
+	PF14	= portF + 14
+	PF15	= portF + 15
+
+	PG0	= portG + 0
+	PG1	= portG + 1
+	PG2	= portG + 2
+	PG3	= portG + 3
+	PG4	= portG + 4
+	PG5	= portG + 5
+	PG6	= portG + 6
+	PG7	= portG + 7
+	PG8	= portG + 8
+	PG9	= portG + 9
+	PG10	= portG + 10
+	PG11	= portG + 11
+	PG12	= portG + 12
+	PG13	= portG + 13
+	PG14	= portG + 14
+	PG15	= portG + 15
+
+	PH0	= portH + 0
+	PH1	= portH + 1
+	PH2	= portH + 2
+	PH3	= portH + 3
+	PH4	= portH + 4
+	PH5	= portH + 5
+	PH6	= portH + 6
+	PH7	= portH + 7
+	PH8	= portH + 8
+	PH9	= portH + 9
+	PH10	= portH + 10
+	PH11	= portH + 11
+	PH12	= portH + 12
+	PH13	= portH + 13
+	PH14	= portH + 14
+	PH15	= portH + 15
+
+	PI0	= portI + 0
+	PI1	= portI + 1
+	PI2	= portI + 2
+	PI3	= portI + 3
+	PI4	= portI + 4
+	PI5	= portI + 5
+	PI6	= portI + 6
+	PI7	= portI + 7
+	PI8	= portI + 8
+	PI9	= portI + 9
+	PI10	= portI + 10
+	PI11	= portI + 11
+	PI12	= portI + 12
+	PI13	= portI + 13
+	PI14	= portI + 14
+	PI15	= portI + 15
+)
+```
+
+
+
+```go
+const (
+	ARR_MAX	= 0x10000
+	PSC_MAX	= 0x10000
+)
+```
+
+
+
+```go
+const APB1_TIM_FREQ = 54e6	// 54MHz
+
+```
+
+Internal use: configured speed of the APB1 and APB2 timers, this should be kept
+in sync with any changes to runtime package which configures the oscillators
+and clock frequencies
+
+
+```go
+const APB2_TIM_FREQ = 216e6	// 216MHz
+
+```
+
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	// USART3 is the hardware serial port connected to the onboard ST-LINK
+	// debugger to be exposed as virtual COM port over USB on Nucleo boards.
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:			NewRingBuffer(),
+		Bus:			stm32.USART3,
+		TxAltFuncSelector:	UART_ALT_FN,
+		RxAltFuncSelector:	UART_ALT_FN,
+	}
+	DefaultUART	= UART1
+)
+```
+
+
+
+```go
+var (
+	// I2C1 is documented, alias to I2C0 as well
+	I2C1	= &I2C{
+		Bus:			stm32.I2C1,
+		AltFuncSelector:	4,
+	}
+	I2C0	= I2C1
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	TIM1	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM1EN,
+		Device:		stm32.TIM1,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{
+				{PA8, AF1_TIM1_2},
+				{PE9, AF1_TIM1_2},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA9, AF1_TIM1_2},
+				{PE11, AF1_TIM1_2},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA10, AF1_TIM1_2},
+				{PE13, AF1_TIM1_2},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA11, AF1_TIM1_2},
+				{PE14, AF1_TIM1_2},
+			}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM2	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM2EN,
+		Device:		stm32.TIM2,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{
+				{PA0, AF1_TIM1_2},
+				{PA5, AF1_TIM1_2},
+				{PA15, AF1_TIM1_2},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA1, AF1_TIM1_2},
+				{PB3, AF1_TIM1_2},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA2, AF1_TIM1_2},
+				{PB10, AF1_TIM1_2},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA3, AF1_TIM1_2},
+				{PB11, AF1_TIM1_2},
+			}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM3	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM3EN,
+		Device:		stm32.TIM3,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{
+				{PA6, AF2_TIM3_4_5},
+				{PB4, AF2_TIM3_4_5},
+				{PC6, AF2_TIM3_4_5},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA7, AF2_TIM3_4_5},
+				{PB5, AF2_TIM3_4_5},
+				{PC7, AF2_TIM3_4_5},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PB0, AF2_TIM3_4_5},
+				{PC8, AF2_TIM3_4_5},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PB1, AF2_TIM3_4_5},
+				{PC9, AF2_TIM3_4_5},
+			}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM4	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM4EN,
+		Device:		stm32.TIM4,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{
+				{PB6, AF2_TIM3_4_5},
+				{PD12, AF2_TIM3_4_5},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PB7, AF2_TIM3_4_5},
+				{PD13, AF2_TIM3_4_5},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PB8, AF2_TIM3_4_5},
+				{PD14, AF2_TIM3_4_5},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PB9, AF2_TIM3_4_5},
+				{PD15, AF2_TIM3_4_5},
+			}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM5	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM5EN,
+		Device:		stm32.TIM5,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{
+				{PA0, AF2_TIM3_4_5},
+				{PH10, AF2_TIM3_4_5},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA1, AF2_TIM3_4_5},
+				{PH11, AF2_TIM3_4_5},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA2, AF2_TIM3_4_5},
+				{PH12, AF2_TIM3_4_5},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA3, AF2_TIM3_4_5},
+				{PI0, AF2_TIM3_4_5},
+			}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM6	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM6EN,
+		Device:		stm32.TIM6,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM7	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM7EN,
+		Device:		stm32.TIM7,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM8	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM8EN,
+		Device:		stm32.TIM8,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{
+				{PC6, AF3_TIM8_9_10_11_LPTIM1},
+				{PI5, AF3_TIM8_9_10_11_LPTIM1},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PC7, AF3_TIM8_9_10_11_LPTIM1},
+				{PI6, AF3_TIM8_9_10_11_LPTIM1},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PC8, AF3_TIM8_9_10_11_LPTIM1},
+				{PI7, AF3_TIM8_9_10_11_LPTIM1},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PC9, AF3_TIM8_9_10_11_LPTIM1},
+				{PI2, AF3_TIM8_9_10_11_LPTIM1},
+			}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM9	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM9EN,
+		Device:		stm32.TIM9,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{
+				{PA2, AF3_TIM8_9_10_11_LPTIM1},
+				{PE5, AF3_TIM8_9_10_11_LPTIM1},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA3, AF3_TIM8_9_10_11_LPTIM1},
+				{PE6, AF3_TIM8_9_10_11_LPTIM1},
+			}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM10	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM10EN,
+		Device:		stm32.TIM10,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{
+				{PB8, AF3_TIM8_9_10_11_LPTIM1},
+				{PF6, AF3_TIM8_9_10_11_LPTIM1},
+			}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM11	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM11EN,
+		Device:		stm32.TIM11,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{
+				{PB9, AF3_TIM8_9_10_11_LPTIM1},
+				{PF7, AF3_TIM8_9_10_11_LPTIM1},
+			}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM12	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM12EN,
+		Device:		stm32.TIM12,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{
+				{PB14, AF9_CAN1_TIM12_13_14_QUADSPI_FMC_OTG2_HS},
+				{PH6, AF9_CAN1_TIM12_13_14_QUADSPI_FMC_OTG2_HS},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PB15, AF9_CAN1_TIM12_13_14_QUADSPI_FMC_OTG2_HS},
+				{PH9, AF9_CAN1_TIM12_13_14_QUADSPI_FMC_OTG2_HS},
+			}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM13	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM13EN,
+		Device:		stm32.TIM13,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{
+				{PA6, AF9_CAN1_TIM12_13_14_QUADSPI_FMC_OTG2_HS},
+				{PF8, AF9_CAN1_TIM12_13_14_QUADSPI_FMC_OTG2_HS},
+			}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM14	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM14EN,
+		Device:		stm32.TIM14,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{
+				{PA7, AF9_CAN1_TIM12_13_14_QUADSPI_FMC_OTG2_HS},
+				{PF9, AF9_CAN1_TIM12_13_14_QUADSPI_FMC_OTG2_HS},
+			}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+)
+```
+
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself.
+
+The length of the device ID for STM32 is 12 bytes (96 bits).
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of cryptographically secure random data
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type ChannelCallback
+
+```go
+type ChannelCallback func(channel uint8)
+```
+
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*stm32.I2C_Type
+	AltFuncSelector	uint8
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration
+
+
+### func (Pin) ConfigureAltFunc
+
+```go
+func (p Pin) ConfigureAltFunc(config PinConfig, altFunc uint8)
+```
+
+Configure this pin with the given configuration including alternate
+
+	function mapping if necessary.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+PortMaskClear returns the register and mask to disable a given port. This can
+be used to implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+PortMaskSet returns the register and mask to enable a given GPIO pin. This
+can be used to implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetAltFunc
+
+```go
+func (p Pin) SetAltFunc(af uint8)
+```
+
+SetAltFunc maps the given alternative function to the I/O pin
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+---------- General pin operations ----------
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinFunction
+
+```go
+type PinFunction struct {
+	Pin	Pin
+	AltFunc	uint8
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type TIM
+
+```go
+type TIM struct {
+	EnableRegister	*volatile.Register32
+	EnableFlag	uint32
+	Device		*stm32.TIM_Type
+	Channels	[4]TimerChannel
+	UpInterrupt	interrupt.Interrupt
+	OCInterrupt	interrupt.Interrupt
+
+	wraparoundCallback	TimerCallback
+	channelCallbacks	[4]ChannelCallback
+
+	busFreq	uint64
+}
+```
+
+
+
+
+### func (*TIM) Channel
+
+```go
+func (t *TIM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*TIM) Configure
+
+```go
+func (t *TIM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+
+
+### func (*TIM) Count
+
+```go
+func (t *TIM) Count() uint32
+```
+
+
+
+### func (*TIM) Set
+
+```go
+func (t *TIM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	t.Set(ch, t.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*TIM) SetInverting
+
+```go
+func (t *TIM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TIM) SetMatchInterrupt
+
+```go
+func (t *TIM) SetMatchInterrupt(channel uint8, callback ChannelCallback) error
+```
+
+Sets a callback to be called when a channel reaches it's set-point.
+
+For example, if `t.Set(ch, t.Top() / 4)` is used then the callback will
+be called every quarter-period of the timer's base Period.
+
+
+### func (*TIM) SetPeriod
+
+```go
+func (t *TIM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TIM) SetWraparoundInterrupt
+
+```go
+func (t *TIM) SetWraparoundInterrupt(callback TimerCallback) error
+```
+
+SetWraparoundInterrupt configures a callback to be called each
+time the timer 'wraps-around'.
+
+For example, if `Configure(PWMConfig{Period:1000000})` is used,
+to set the timer period to 1ms, this callback will be called every
+1ms.
+
+
+### func (*TIM) Top
+
+```go
+func (t *TIM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+### func (*TIM) Unset
+
+```go
+func (t *TIM) Unset(channel uint8)
+```
+
+Unset disables a channel, including any configured interrupts.
+
+
+
+
+## type TimerCallback
+
+```go
+type TimerCallback func()
+```
+
+
+
+
+
+
+## type TimerChannel
+
+```go
+type TimerChannel struct {
+	Pins []PinFunction
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer			*RingBuffer
+	Bus			*stm32.USART_Type
+	Interrupt		interrupt.Interrupt
+	TxAltFuncSelector	uint8
+	RxAltFuncSelector	uint8
+
+	// Registers specific to the chip
+	rxReg		*volatile.Register32
+	txReg		*volatile.Register32
+	statusReg	*volatile.Register32
+	txEmptyFlag	uint32
+}
+```
+
+UART representation
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART. Defer to chip-specific
+routines for calculation
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/nucleo-l031k6.md b/content/docs/reference/microcontrollers/machine/nucleo-l031k6.md
new file mode 100644
index 00000000..d18c0b8b
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/nucleo-l031k6.md
@@ -0,0 +1,1496 @@
+
+---
+title: nucleo-l031k6
+---
+
+
+## Constants
+
+```go
+const (
+	// Arduino Pins
+	A0	= PA0	// ADC_IN0
+	A1	= PA1	// ADC_IN1
+	A2	= PA3	// ADC_IN3
+	A3	= PA4	// ADC_IN4
+	A4	= PA5	// ADC_IN5 || I2C1_SDA
+	A5	= PA6	// ADC_IN6 || I2C1_SCL
+	A6	= PA7	// ADC_IN7
+	A7	= PA2	// ADC_IN2
+
+	D0	= PA10	// USART1_TX
+	D1	= PA9	// USART1_RX
+	D2	= PA12
+	D3	= PB0	// TIM2_CH3
+	D4	= PB7
+	D5	= PB6	// TIM16_CH1N
+	D6	= PB1	// TIM14_CH1
+	D9	= PA8	// TIM1_CH1
+	D10	= PA11	// SPI_CS || TIM1_CH4
+	D11	= PB5	// SPI1_MOSI || TIM3_CH2
+	D12	= PB4	// SPI1_MISO
+	D13	= PB3	// SPI1_SCK
+)
+```
+
+
+
+```go
+const (
+	LED		= LED_BUILTIN
+	LED_BUILTIN	= LED_GREEN
+	LED_GREEN	= PB3
+)
+```
+
+
+
+```go
+const (
+	// This board does not have a user button, so
+	// use first GPIO pin by default
+	BUTTON = PA0
+)
+```
+
+
+
+```go
+const (
+	// UART pins
+	// PA2 and PA15 are connected to the ST-Link Virtual Com Port (VCP)
+	UART_TX_PIN	= PA2
+	UART_RX_PIN	= PA15
+
+	// SPI
+	SPI1_SCK_PIN	= PB3
+	SPI1_SDI_PIN	= PB5
+	SPI1_SDO_PIN	= PB4
+	SPI0_SCK_PIN	= SPI1_SCK_PIN
+	SPI0_SDI_PIN	= SPI1_SDI_PIN
+	SPI0_SDO_PIN	= SPI1_SDO_PIN
+
+	// I2C pins
+	// PB6 and PB7 are mapped to CN4 pin 7 and CN4 pin 8 respectively with the
+	// default solder bridge settings
+	I2C0_SCL_PIN	= PB7
+	I2C0_SDA_PIN	= PB6
+	I2C0_ALT_FUNC	= 1
+)
+```
+
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinRising	PinChange	= 1 << iota
+	PinFalling
+	PinToggle	= PinRising | PinFalling
+)
+```
+
+
+
+```go
+const (
+	MAX_NBYTE_SIZE	= 255
+
+	// 100ms delay = 100e6ns / 16ns
+	// In runtime_stm32_timers.go, tick is fixed at 16ns per tick
+	TIMEOUT_TICKS	= 100e6 / 16
+
+	I2C_NO_STARTSTOP		= 0x0
+	I2C_GENERATE_START_WRITE	= 0x80000000 | stm32.I2C_CR2_START
+	I2C_GENERATE_START_READ		= 0x80000000 | stm32.I2C_CR2_START | stm32.I2C_CR2_RD_WRN
+	I2C_GENERATE_STOP		= 0x80000000 | stm32.I2C_CR2_STOP
+)
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (32.768s)
+	//
+	// Timeout is based on 12-bit counter with /256 divider on
+	// 32.768kHz clock.  See 21.3.3 of RM0090 for table.
+	WatchdogMaxTimeout = ((0xfff + 1) * 256 * 1024) / 32768
+)
+```
+
+
+
+```go
+const (
+	// Mode Flag
+	PinOutput		PinMode	= 0
+	PinInput		PinMode	= PinInputFloating
+	PinInputFloating	PinMode	= 1
+	PinInputPulldown	PinMode	= 2
+	PinInputPullup		PinMode	= 3
+
+	// for UART
+	PinModeUARTTX	PinMode	= 4
+	PinModeUARTRX	PinMode	= 5
+
+	// for I2C
+	PinModeI2CSCL	PinMode	= 6
+	PinModeI2CSDA	PinMode	= 7
+
+	// for SPI
+	PinModeSPICLK	PinMode	= 8
+	PinModeSPISDO	PinMode	= 9
+	PinModeSPISDI	PinMode	= 10
+
+	// for analog/ADC
+	PinInputAnalog	PinMode	= 11
+
+	// for PWM
+	PinModePWMOutput	PinMode	= 12
+)
+```
+
+
+
+```go
+const PWM_MODE1 = 0x6
+```
+
+
+
+```go
+const APB1_TIM_FREQ = 32e6	// 32MHz
+
+```
+
+Internal use: configured speed of the APB1 and APB2 timers, this should be kept
+in sync with any changes to runtime package which configures the oscillators
+and clock frequencies
+
+
+```go
+const APB2_TIM_FREQ = 32e6	// 32MHz
+
+```
+
+
+
+```go
+const (
+	PA0	= portA + 0
+	PA1	= portA + 1
+	PA2	= portA + 2
+	PA3	= portA + 3
+	PA4	= portA + 4
+	PA5	= portA + 5
+	PA6	= portA + 6
+	PA7	= portA + 7
+	PA8	= portA + 8
+	PA9	= portA + 9
+	PA10	= portA + 10
+	PA11	= portA + 11
+	PA12	= portA + 12
+	PA13	= portA + 13
+	PA14	= portA + 14
+	PA15	= portA + 15
+
+	PB0	= portB + 0
+	PB1	= portB + 1
+	PB2	= portB + 2
+	PB3	= portB + 3
+	PB4	= portB + 4
+	PB5	= portB + 5
+	PB6	= portB + 6
+	PB7	= portB + 7
+	PB8	= portB + 8
+	PB9	= portB + 9
+	PB10	= portB + 10
+	PB11	= portB + 11
+	PB12	= portB + 12
+	PB13	= portB + 13
+	PB14	= portB + 14
+	PB15	= portB + 15
+
+	PC0	= portC + 0
+	PC1	= portC + 1
+	PC2	= portC + 2
+	PC3	= portC + 3
+	PC4	= portC + 4
+	PC5	= portC + 5
+	PC6	= portC + 6
+	PC7	= portC + 7
+	PC8	= portC + 8
+	PC9	= portC + 9
+	PC10	= portC + 10
+	PC11	= portC + 11
+	PC12	= portC + 12
+	PC13	= portC + 13
+	PC14	= portC + 14
+	PC15	= portC + 15
+
+	PD0	= portD + 0
+	PD1	= portD + 1
+	PD2	= portD + 2
+	PD3	= portD + 3
+	PD4	= portD + 4
+	PD5	= portD + 5
+	PD6	= portD + 6
+	PD7	= portD + 7
+	PD8	= portD + 8
+	PD9	= portD + 9
+	PD10	= portD + 10
+	PD11	= portD + 11
+	PD12	= portD + 12
+	PD13	= portD + 13
+	PD14	= portD + 14
+	PD15	= portD + 15
+
+	PE0	= portE + 0
+	PE1	= portE + 1
+	PE2	= portE + 2
+	PE3	= portE + 3
+	PE4	= portE + 4
+	PE5	= portE + 5
+	PE6	= portE + 6
+	PE7	= portE + 7
+	PE8	= portE + 8
+	PE9	= portE + 9
+	PE10	= portE + 10
+	PE11	= portE + 11
+	PE12	= portE + 12
+	PE13	= portE + 13
+	PE14	= portE + 14
+	PE15	= portE + 15
+
+	PH0	= portH + 0
+	PH1	= portH + 1
+)
+```
+
+
+
+```go
+const (
+	AF0_SYSTEM_SPI1_USART2_LPTIM_TIM21	= 0
+	AF1_SPI1_I2C1_LPTIM			= 1
+	AF2_LPTIM_TIM2				= 2
+	AF3_I2C1				= 3
+	AF4_I2C1_USART2_LPUART1_TIM22		= 4
+	AF5_TIM2_21_22				= 5
+	AF6_LPUART1				= 6
+	AF7_COMP1_2				= 7
+)
+```
+
+
+
+```go
+const (
+	ARR_MAX	= 0x10000
+	PSC_MAX	= 0x10000
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	// USART2 is the hardware serial port connected to the onboard ST-LINK
+	// debugger to be exposed as virtual COM port over USB on Nucleo boards.
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:			NewRingBuffer(),
+		Bus:			stm32.USART2,
+		TxAltFuncSelector:	4,
+		RxAltFuncSelector:	4,
+	}
+	DefaultUART	= UART1
+
+	// I2C1 is documented, alias to I2C0 as well
+	I2C1	= &I2C{
+		Bus:			stm32.I2C1,
+		AltFuncSelector:	1,
+	}
+	I2C0	= I2C1
+
+	// SPI
+	SPI0	= &SPI{
+		Bus:			stm32.SPI1,
+		AltFuncSelector:	0,
+	}
+	SPI1	= SPI0
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	TIM2	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM2EN,
+		Device:		stm32.TIM2,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA0, AF2_LPTIM_TIM2}, {PA5, AF5_TIM2_21_22}, {PA8, AF5_TIM2_21_22}, {PA15, AF5_TIM2_21_22}}},
+			TimerChannel{Pins: []PinFunction{{PA1, AF2_LPTIM_TIM2}, {PB3, AF2_LPTIM_TIM2}}},
+			TimerChannel{Pins: []PinFunction{{PA2, AF2_LPTIM_TIM2}, {PB0, AF5_TIM2_21_22}, {PB10, AF2_LPTIM_TIM2}}},
+			TimerChannel{Pins: []PinFunction{{PA3, AF2_LPTIM_TIM2}, {PB1, AF5_TIM2_21_22}, {PB11, AF2_LPTIM_TIM2}}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM3	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM3EN,
+		Device:		stm32.TIM3,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM6	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM6EN,
+		Device:		stm32.TIM6,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM7	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM7EN,
+		Device:		stm32.TIM7,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM21	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM21EN,
+		Device:		stm32.TIM21,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM22	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM22EN,
+		Device:		stm32.TIM2,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+)
+```
+
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself.
+
+The length of the device ID for STM32 is 12 bytes (96 bits).
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type ChannelCallback
+
+```go
+type ChannelCallback func(channel uint8)
+```
+
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*stm32.I2C_Type
+	AltFuncSelector	uint8
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration
+
+
+### func (Pin) ConfigureAltFunc
+
+```go
+func (p Pin) ConfigureAltFunc(config PinConfig, altFunc uint8)
+```
+
+Configure this pin with the given configuration including alternate
+
+	function mapping if necessary.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+PortMaskClear returns the register and mask to disable a given port. This can
+be used to implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+PortMaskSet returns the register and mask to enable a given GPIO pin. This
+can be used to implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetAltFunc
+
+```go
+func (p Pin) SetAltFunc(af uint8)
+```
+
+SetAltFunc maps the given alternative function to the I/O pin
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+---------- General pin operations ----------
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinFunction
+
+```go
+type PinFunction struct {
+	Pin	Pin
+	AltFunc	uint8
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus		*stm32.SPI_Type
+	AltFuncSelector	uint8
+}
+```
+
+SPI on the STM32Fxxx using MODER / alternate function pins
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the STM32 SPI1 interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type TIM
+
+```go
+type TIM struct {
+	EnableRegister	*volatile.Register32
+	EnableFlag	uint32
+	Device		*stm32.TIM_Type
+	Channels	[4]TimerChannel
+	UpInterrupt	interrupt.Interrupt
+	OCInterrupt	interrupt.Interrupt
+
+	wraparoundCallback	TimerCallback
+	channelCallbacks	[4]ChannelCallback
+
+	busFreq	uint64
+}
+```
+
+
+
+
+### func (*TIM) Channel
+
+```go
+func (t *TIM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*TIM) Configure
+
+```go
+func (t *TIM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+
+
+### func (*TIM) Count
+
+```go
+func (t *TIM) Count() uint32
+```
+
+
+
+### func (*TIM) Set
+
+```go
+func (t *TIM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	t.Set(ch, t.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*TIM) SetInverting
+
+```go
+func (t *TIM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TIM) SetMatchInterrupt
+
+```go
+func (t *TIM) SetMatchInterrupt(channel uint8, callback ChannelCallback) error
+```
+
+Sets a callback to be called when a channel reaches it's set-point.
+
+For example, if `t.Set(ch, t.Top() / 4)` is used then the callback will
+be called every quarter-period of the timer's base Period.
+
+
+### func (*TIM) SetPeriod
+
+```go
+func (t *TIM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TIM) SetWraparoundInterrupt
+
+```go
+func (t *TIM) SetWraparoundInterrupt(callback TimerCallback) error
+```
+
+SetWraparoundInterrupt configures a callback to be called each
+time the timer 'wraps-around'.
+
+For example, if `Configure(PWMConfig{Period:1000000})` is used,
+to set the timer period to 1ms, this callback will be called every
+1ms.
+
+
+### func (*TIM) Top
+
+```go
+func (t *TIM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+### func (*TIM) Unset
+
+```go
+func (t *TIM) Unset(channel uint8)
+```
+
+Unset disables a channel, including any configured interrupts.
+
+
+
+
+## type TimerCallback
+
+```go
+type TimerCallback func()
+```
+
+
+
+
+
+
+## type TimerChannel
+
+```go
+type TimerChannel struct {
+	Pins []PinFunction
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer			*RingBuffer
+	Bus			*stm32.USART_Type
+	Interrupt		interrupt.Interrupt
+	TxAltFuncSelector	uint8
+	RxAltFuncSelector	uint8
+
+	// Registers specific to the chip
+	rxReg		*volatile.Register32
+	txReg		*volatile.Register32
+	statusReg	*volatile.Register32
+	txEmptyFlag	uint32
+}
+```
+
+UART representation
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART. Defer to chip-specific
+routines for calculation
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/nucleo-l432kc.md b/content/docs/reference/microcontrollers/machine/nucleo-l432kc.md
new file mode 100644
index 00000000..f00c53fc
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/nucleo-l432kc.md
@@ -0,0 +1,1618 @@
+
+---
+title: nucleo-l432kc
+---
+
+
+## Constants
+
+```go
+const (
+	// Arduino Pins
+	A0	= PA0
+	A1	= PA1
+	A2	= PA3
+	A3	= PA4
+	A4	= PA5
+	A5	= PA6
+	A6	= PA7
+	A7	= PA2
+
+	D0	= PA10
+	D1	= PA9
+	D2	= PA12
+	D3	= PB0
+	D4	= PB7
+	D5	= PB6
+	D6	= PB1
+	D7	= PC14
+	D8	= PC15
+	D9	= PA8
+	D10	= PA11
+	D11	= PB5
+	D12	= PB4
+	D13	= PB3
+)
+```
+
+
+
+```go
+const (
+	LED		= LED_BUILTIN
+	LED_BUILTIN	= LED_GREEN
+	LED_GREEN	= PB3
+)
+```
+
+
+
+```go
+const (
+	// This board does not have a user button, so
+	// use first GPIO pin by default
+	BUTTON = PA0
+)
+```
+
+
+
+```go
+const (
+	// UART pins
+	// PA2 and PA15 are connected to the ST-Link Virtual Com Port (VCP)
+	UART_TX_PIN	= PA2
+	UART_RX_PIN	= PA15
+
+	// I2C pins
+	// With default solder bridge settings:
+	//    PB6 / Arduino D5 / CN3 Pin 8 is SCL
+	//    PB7 / Arduino D4 / CN3 Pin 7 is SDA
+	I2C0_SCL_PIN	= PB6
+	I2C0_SDA_PIN	= PB7
+
+	// SPI pins
+	SPI1_SCK_PIN	= PB3
+	SPI1_SDI_PIN	= PB5
+	SPI1_SDO_PIN	= PB4
+	SPI0_SCK_PIN	= SPI1_SCK_PIN
+	SPI0_SDI_PIN	= SPI1_SDI_PIN
+	SPI0_SDO_PIN	= SPI1_SDO_PIN
+)
+```
+
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinRising	PinChange	= 1 << iota
+	PinFalling
+	PinToggle	= PinRising | PinFalling
+)
+```
+
+
+
+```go
+const (
+	MAX_NBYTE_SIZE	= 255
+
+	// 100ms delay = 100e6ns / 16ns
+	// In runtime_stm32_timers.go, tick is fixed at 16ns per tick
+	TIMEOUT_TICKS	= 100e6 / 16
+
+	I2C_NO_STARTSTOP		= 0x0
+	I2C_GENERATE_START_WRITE	= 0x80000000 | stm32.I2C_CR2_START
+	I2C_GENERATE_START_READ		= 0x80000000 | stm32.I2C_CR2_START | stm32.I2C_CR2_RD_WRN
+	I2C_GENERATE_STOP		= 0x80000000 | stm32.I2C_CR2_STOP
+)
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (32.768s)
+	//
+	// Timeout is based on 12-bit counter with /256 divider on
+	// 32.768kHz clock.  See 21.3.3 of RM0090 for table.
+	WatchdogMaxTimeout = ((0xfff + 1) * 256 * 1024) / 32768
+)
+```
+
+
+
+```go
+const (
+	// Mode Flag
+	PinOutput		PinMode	= 0
+	PinInput		PinMode	= PinInputFloating
+	PinInputFloating	PinMode	= 1
+	PinInputPulldown	PinMode	= 2
+	PinInputPullup		PinMode	= 3
+
+	// for UART
+	PinModeUARTTX	PinMode	= 4
+	PinModeUARTRX	PinMode	= 5
+
+	// for I2C
+	PinModeI2CSCL	PinMode	= 6
+	PinModeI2CSDA	PinMode	= 7
+
+	// for SPI
+	PinModeSPICLK	PinMode	= 8
+	PinModeSPISDO	PinMode	= 9
+	PinModeSPISDI	PinMode	= 10
+
+	// for analog/ADC
+	PinInputAnalog	PinMode	= 11
+
+	// for PWM
+	PinModePWMOutput	PinMode	= 12
+)
+```
+
+
+
+```go
+const RNG_MAX_READ_RETRIES = 1000
+```
+
+
+
+```go
+const PWM_MODE1 = 0x6
+```
+
+
+
+```go
+const (
+	AF0_SYSTEM		= 0
+	AF1_TIM1_2_LPTIM1	= 1
+	AF2_TIM1_2		= 2
+	AF3_USART2		= 3
+	AF4_I2C1_2_3		= 4
+	AF5_SPI1_2		= 5
+	AF6_SPI3		= 6
+	AF7_USART1_2_3		= 7
+	AF8_LPUART1		= 8
+	AF9_CAN1_TSC		= 9
+	AF10_USB_QUADSPI	= 10
+	AF12_COMP1_2_SWPMI1	= 12
+	AF13_SAI1		= 13
+	AF14_TIM2_15_16_LPTIM2	= 14
+	AF15_EVENTOUT		= 15
+)
+```
+
+
+
+```go
+const (
+	PA0	= portA + 0
+	PA1	= portA + 1
+	PA2	= portA + 2
+	PA3	= portA + 3
+	PA4	= portA + 4
+	PA5	= portA + 5
+	PA6	= portA + 6
+	PA7	= portA + 7
+	PA8	= portA + 8
+	PA9	= portA + 9
+	PA10	= portA + 10
+	PA11	= portA + 11
+	PA12	= portA + 12
+	PA13	= portA + 13
+	PA14	= portA + 14
+	PA15	= portA + 15
+
+	PB0	= portB + 0
+	PB1	= portB + 1
+	PB2	= portB + 2
+	PB3	= portB + 3
+	PB4	= portB + 4
+	PB5	= portB + 5
+	PB6	= portB + 6
+	PB7	= portB + 7
+	PB8	= portB + 8
+	PB9	= portB + 9
+	PB10	= portB + 10
+	PB11	= portB + 11
+	PB12	= portB + 12
+	PB13	= portB + 13
+	PB14	= portB + 14
+	PB15	= portB + 15
+
+	PC0	= portC + 0
+	PC1	= portC + 1
+	PC2	= portC + 2
+	PC3	= portC + 3
+	PC4	= portC + 4
+	PC5	= portC + 5
+	PC6	= portC + 6
+	PC7	= portC + 7
+	PC8	= portC + 8
+	PC9	= portC + 9
+	PC10	= portC + 10
+	PC11	= portC + 11
+	PC12	= portC + 12
+	PC13	= portC + 13
+	PC14	= portC + 14
+	PC15	= portC + 15
+
+	PD0	= portD + 0
+	PD1	= portD + 1
+	PD2	= portD + 2
+	PD3	= portD + 3
+	PD4	= portD + 4
+	PD5	= portD + 5
+	PD6	= portD + 6
+	PD7	= portD + 7
+	PD8	= portD + 8
+	PD9	= portD + 9
+	PD10	= portD + 10
+	PD11	= portD + 11
+	PD12	= portD + 12
+	PD13	= portD + 13
+	PD14	= portD + 14
+	PD15	= portD + 15
+
+	PE0	= portE + 0
+	PE1	= portE + 1
+	PE2	= portE + 2
+	PE3	= portE + 3
+	PE4	= portE + 4
+	PE5	= portE + 5
+	PE6	= portE + 6
+	PE7	= portE + 7
+	PE8	= portE + 8
+	PE9	= portE + 9
+	PE10	= portE + 10
+	PE11	= portE + 11
+	PE12	= portE + 12
+	PE13	= portE + 13
+	PE14	= portE + 14
+	PE15	= portE + 15
+)
+```
+
+
+
+```go
+const (
+	ARR_MAX	= 0x10000
+	PSC_MAX	= 0x10000
+)
+```
+
+
+
+```go
+const APB1_TIM_FREQ = 80e6	// 80MHz
+
+```
+
+Internal use: configured speed of the APB1 and APB2 timers, this should be kept
+in sync with any changes to runtime package which configures the oscillators
+and clock frequencies
+
+
+```go
+const APB2_TIM_FREQ = 80e6	// 80MHz
+
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	// USART2 is the hardware serial port connected to the onboard ST-LINK
+	// debugger to be exposed as virtual COM port over USB on Nucleo boards.
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:			NewRingBuffer(),
+		Bus:			stm32.USART2,
+		TxAltFuncSelector:	7,
+		RxAltFuncSelector:	3,
+	}
+	DefaultUART	= UART1
+
+	// I2C1 is documented, alias to I2C0 as well
+	I2C1	= &I2C{
+		Bus:			stm32.I2C1,
+		AltFuncSelector:	4,
+	}
+	I2C0	= I2C1
+
+	// SPI1 is documented, alias to SPI0 as well
+	SPI1	= &SPI{
+		Bus:			stm32.SPI1,
+		AltFuncSelector:	5,
+	}
+	SPI0	= SPI1
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	TIM1	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM1EN,
+		Device:		stm32.TIM1,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{
+				{PA8, AF1_TIM1_2_LPTIM1},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA9, AF1_TIM1_2_LPTIM1},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA10, AF1_TIM1_2_LPTIM1},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA11, AF1_TIM1_2_LPTIM1},
+			}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM2	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR1,
+		EnableFlag:	stm32.RCC_APB1ENR1_TIM2EN,
+		Device:		stm32.TIM2,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{
+				{PA0, AF1_TIM1_2_LPTIM1},
+				{PA5, AF1_TIM1_2_LPTIM1},
+				{PA15, AF1_TIM1_2_LPTIM1},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA1, AF1_TIM1_2_LPTIM1},
+				{PB3, AF1_TIM1_2_LPTIM1},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA2, AF1_TIM1_2_LPTIM1},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA3, AF1_TIM1_2_LPTIM1},
+			}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM3	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR1,
+		EnableFlag:	stm32.RCC_APB1ENR1_TIM3EN,
+		Device:		stm32.TIM3,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM6	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR1,
+		EnableFlag:	stm32.RCC_APB1ENR1_TIM6EN,
+		Device:		stm32.TIM6,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM7	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR1,
+		EnableFlag:	stm32.RCC_APB1ENR1_TIM7EN,
+		Device:		stm32.TIM7,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM15	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM15EN,
+		Device:		stm32.TIM15,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{
+				{PA2, AF14_TIM2_15_16_LPTIM2},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA3, AF14_TIM2_15_16_LPTIM2},
+			}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM16	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM16EN,
+		Device:		stm32.TIM16,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{
+				{PA6, AF14_TIM2_15_16_LPTIM2},
+			}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+)
+```
+
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself.
+
+The length of the device ID for STM32 is 12 bytes (96 bits).
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of cryptographically secure random data
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type ChannelCallback
+
+```go
+type ChannelCallback func(channel uint8)
+```
+
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*stm32.I2C_Type
+	AltFuncSelector	uint8
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration
+
+
+### func (Pin) ConfigureAltFunc
+
+```go
+func (p Pin) ConfigureAltFunc(config PinConfig, altFunc uint8)
+```
+
+Configure this pin with the given configuration including alternate
+
+	function mapping if necessary.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+PortMaskClear returns the register and mask to disable a given port. This can
+be used to implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+PortMaskSet returns the register and mask to enable a given GPIO pin. This
+can be used to implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetAltFunc
+
+```go
+func (p Pin) SetAltFunc(af uint8)
+```
+
+SetAltFunc maps the given alternative function to the I/O pin
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+---------- General pin operations ----------
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinFunction
+
+```go
+type PinFunction struct {
+	Pin	Pin
+	AltFunc	uint8
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus		*stm32.SPI_Type
+	AltFuncSelector	uint8
+}
+```
+
+SPI on the STM32Fxxx using MODER / alternate function pins
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the STM32 SPI1 interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type TIM
+
+```go
+type TIM struct {
+	EnableRegister	*volatile.Register32
+	EnableFlag	uint32
+	Device		*stm32.TIM_Type
+	Channels	[4]TimerChannel
+	UpInterrupt	interrupt.Interrupt
+	OCInterrupt	interrupt.Interrupt
+
+	wraparoundCallback	TimerCallback
+	channelCallbacks	[4]ChannelCallback
+
+	busFreq	uint64
+}
+```
+
+
+
+
+### func (*TIM) Channel
+
+```go
+func (t *TIM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*TIM) Configure
+
+```go
+func (t *TIM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+
+
+### func (*TIM) Count
+
+```go
+func (t *TIM) Count() uint32
+```
+
+
+
+### func (*TIM) Set
+
+```go
+func (t *TIM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	t.Set(ch, t.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*TIM) SetInverting
+
+```go
+func (t *TIM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TIM) SetMatchInterrupt
+
+```go
+func (t *TIM) SetMatchInterrupt(channel uint8, callback ChannelCallback) error
+```
+
+Sets a callback to be called when a channel reaches it's set-point.
+
+For example, if `t.Set(ch, t.Top() / 4)` is used then the callback will
+be called every quarter-period of the timer's base Period.
+
+
+### func (*TIM) SetPeriod
+
+```go
+func (t *TIM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TIM) SetWraparoundInterrupt
+
+```go
+func (t *TIM) SetWraparoundInterrupt(callback TimerCallback) error
+```
+
+SetWraparoundInterrupt configures a callback to be called each
+time the timer 'wraps-around'.
+
+For example, if `Configure(PWMConfig{Period:1000000})` is used,
+to set the timer period to 1ms, this callback will be called every
+1ms.
+
+
+### func (*TIM) Top
+
+```go
+func (t *TIM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+### func (*TIM) Unset
+
+```go
+func (t *TIM) Unset(channel uint8)
+```
+
+Unset disables a channel, including any configured interrupts.
+
+
+
+
+## type TimerCallback
+
+```go
+type TimerCallback func()
+```
+
+
+
+
+
+
+## type TimerChannel
+
+```go
+type TimerChannel struct {
+	Pins []PinFunction
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer			*RingBuffer
+	Bus			*stm32.USART_Type
+	Interrupt		interrupt.Interrupt
+	TxAltFuncSelector	uint8
+	RxAltFuncSelector	uint8
+
+	// Registers specific to the chip
+	rxReg		*volatile.Register32
+	txReg		*volatile.Register32
+	statusReg	*volatile.Register32
+	txEmptyFlag	uint32
+}
+```
+
+UART representation
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART. Defer to chip-specific
+routines for calculation
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/nucleo-l552ze.md b/content/docs/reference/microcontrollers/machine/nucleo-l552ze.md
new file mode 100644
index 00000000..79e5d5ab
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/nucleo-l552ze.md
@@ -0,0 +1,1486 @@
+
+---
+title: nucleo-l552ze
+---
+
+
+## Constants
+
+```go
+const (
+	LED_GREEN	= PC7
+	LED_BLUE	= PB7
+	LED_RED		= PA9
+	LED_BUILTIN	= LED_GREEN
+	LED		= LED_BUILTIN
+)
+```
+
+
+
+```go
+const (
+	BUTTON		= BUTTON_USER
+	BUTTON_USER	= PC13
+)
+```
+
+
+
+```go
+const (
+	// PG7 and PG8 are connected to the ST-Link Virtual Com Port (VCP)
+	UART_TX_PIN	= PG7
+	UART_RX_PIN	= PG8
+	UART_ALT_FN	= 8	// GPIO_AF8_LPUART1
+)
+```
+
+UART pins
+
+
+```go
+const (
+	I2C0_SCL_PIN	= PB8
+	I2C0_SDA_PIN	= PB9
+)
+```
+
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinRising	PinChange	= 1 << iota
+	PinFalling
+	PinToggle	= PinRising | PinFalling
+)
+```
+
+
+
+```go
+const (
+	MAX_NBYTE_SIZE	= 255
+
+	// 100ms delay = 100e6ns / 16ns
+	// In runtime_stm32_timers.go, tick is fixed at 16ns per tick
+	TIMEOUT_TICKS	= 100e6 / 16
+
+	I2C_NO_STARTSTOP		= 0x0
+	I2C_GENERATE_START_WRITE	= 0x80000000 | stm32.I2C_CR2_START
+	I2C_GENERATE_START_READ		= 0x80000000 | stm32.I2C_CR2_START | stm32.I2C_CR2_RD_WRN
+	I2C_GENERATE_STOP		= 0x80000000 | stm32.I2C_CR2_STOP
+)
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (32.768s)
+	//
+	// Timeout is based on 12-bit counter with /256 divider on
+	// 32.768kHz clock.  See 21.3.3 of RM0090 for table.
+	WatchdogMaxTimeout = ((0xfff + 1) * 256 * 1024) / 32768
+)
+```
+
+
+
+```go
+const (
+	// Mode Flag
+	PinOutput		PinMode	= 0
+	PinInput		PinMode	= PinInputFloating
+	PinInputFloating	PinMode	= 1
+	PinInputPulldown	PinMode	= 2
+	PinInputPullup		PinMode	= 3
+
+	// for UART
+	PinModeUARTTX	PinMode	= 4
+	PinModeUARTRX	PinMode	= 5
+
+	// for I2C
+	PinModeI2CSCL	PinMode	= 6
+	PinModeI2CSDA	PinMode	= 7
+
+	// for SPI
+	PinModeSPICLK	PinMode	= 8
+	PinModeSPISDO	PinMode	= 9
+	PinModeSPISDI	PinMode	= 10
+
+	// for analog/ADC
+	PinInputAnalog	PinMode	= 11
+
+	// for PWM
+	PinModePWMOutput	PinMode	= 12
+)
+```
+
+
+
+```go
+const RNG_MAX_READ_RETRIES = 1000
+```
+
+
+
+```go
+const PWM_MODE1 = 0x6
+```
+
+
+
+```go
+const (
+	AF0_SYSTEM					= 0
+	AF1_TIM1_2_5_8_LPTIM1				= 1
+	AF2_TIM1_2_3_4_5_LPTIM3				= 2
+	AF3_SPI2_SAI1_I2C4_USART2_TIM1_8_OCTOSPI1	= 3
+	AF4_I2C1_2_3_4					= 4
+	AF5_SPI1_2_3_I2C4_DFSDM1_OCTOSPI1		= 5
+	AF6_SPI3_I2C3_DFSDM1_COMP1			= 6
+	AF7_USART1_2_3					= 7
+	AF8_UART4_5_LPUART1_SDMMC1			= 8
+	AF9_FDCAN1_TSC					= 9
+	AF10_USB_OCTOSPI1				= 10
+	AF11_UCPD1					= 11
+	AF12_SDMMC1_COMP1_2_TIM1_8_FMC			= 12
+	AF13_SAI1_2_TIM8				= 13
+	AF14_TIM2_8_15_16_17_LPTIM2			= 14
+	AF15_EVENTOUT					= 15
+)
+```
+
+
+
+```go
+const (
+	PA0	= portA + 0
+	PA1	= portA + 1
+	PA2	= portA + 2
+	PA3	= portA + 3
+	PA4	= portA + 4
+	PA5	= portA + 5
+	PA6	= portA + 6
+	PA7	= portA + 7
+	PA8	= portA + 8
+	PA9	= portA + 9
+	PA10	= portA + 10
+	PA11	= portA + 11
+	PA12	= portA + 12
+	PA13	= portA + 13
+	PA14	= portA + 14
+	PA15	= portA + 15
+
+	PB0	= portB + 0
+	PB1	= portB + 1
+	PB2	= portB + 2
+	PB3	= portB + 3
+	PB4	= portB + 4
+	PB5	= portB + 5
+	PB6	= portB + 6
+	PB7	= portB + 7
+	PB8	= portB + 8
+	PB9	= portB + 9
+	PB10	= portB + 10
+	PB11	= portB + 11
+	PB12	= portB + 12
+	PB13	= portB + 13
+	PB14	= portB + 14
+	PB15	= portB + 15
+
+	PC0	= portC + 0
+	PC1	= portC + 1
+	PC2	= portC + 2
+	PC3	= portC + 3
+	PC4	= portC + 4
+	PC5	= portC + 5
+	PC6	= portC + 6
+	PC7	= portC + 7
+	PC8	= portC + 8
+	PC9	= portC + 9
+	PC10	= portC + 10
+	PC11	= portC + 11
+	PC12	= portC + 12
+	PC13	= portC + 13
+	PC14	= portC + 14
+	PC15	= portC + 15
+
+	PD0	= portD + 0
+	PD1	= portD + 1
+	PD2	= portD + 2
+	PD3	= portD + 3
+	PD4	= portD + 4
+	PD5	= portD + 5
+	PD6	= portD + 6
+	PD7	= portD + 7
+	PD8	= portD + 8
+	PD9	= portD + 9
+	PD10	= portD + 10
+	PD11	= portD + 11
+	PD12	= portD + 12
+	PD13	= portD + 13
+	PD14	= portD + 14
+	PD15	= portD + 15
+
+	PE0	= portE + 0
+	PE1	= portE + 1
+	PE2	= portE + 2
+	PE3	= portE + 3
+	PE4	= portE + 4
+	PE5	= portE + 5
+	PE6	= portE + 6
+	PE7	= portE + 7
+	PE8	= portE + 8
+	PE9	= portE + 9
+	PE10	= portE + 10
+	PE11	= portE + 11
+	PE12	= portE + 12
+	PE13	= portE + 13
+	PE14	= portE + 14
+	PE15	= portE + 15
+
+	PF0	= portF + 0
+	PF1	= portF + 1
+	PF2	= portF + 2
+	PF3	= portF + 3
+	PF4	= portF + 4
+	PF5	= portF + 5
+	PF6	= portF + 6
+	PF7	= portF + 7
+	PF8	= portF + 8
+	PF9	= portF + 9
+	PF10	= portF + 10
+	PF11	= portF + 11
+	PF12	= portF + 12
+	PF13	= portF + 13
+	PF14	= portF + 14
+	PF15	= portF + 15
+
+	PG0	= portG + 0
+	PG1	= portG + 1
+	PG2	= portG + 2
+	PG3	= portG + 3
+	PG4	= portG + 4
+	PG5	= portG + 5
+	PG6	= portG + 6
+	PG7	= portG + 7
+	PG8	= portG + 8
+	PG9	= portG + 9
+	PG10	= portG + 10
+	PG11	= portG + 11
+	PG12	= portG + 12
+	PG13	= portG + 13
+	PG14	= portG + 14
+	PG15	= portG + 15
+
+	PH0	= portH + 0
+	PH1	= portH + 1
+)
+```
+
+
+
+```go
+const (
+	ARR_MAX	= 0x10000
+	PSC_MAX	= 0x10000
+)
+```
+
+
+
+```go
+const APB1_TIM_FREQ = 110e6	// 110MHz
+
+```
+
+Internal use: configured speed of the APB1 and APB2 timers, this should be kept
+in sync with any changes to runtime package which configures the oscillators
+and clock frequencies
+
+
+```go
+const APB2_TIM_FREQ = 110e6	// 110MHz
+
+```
+
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	// LPUART1 is the hardware serial port connected to the onboard ST-LINK
+	// debugger to be exposed as virtual COM port over USB on Nucleo boards.
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:			NewRingBuffer(),
+		Bus:			stm32.LPUART1,
+		TxAltFuncSelector:	UART_ALT_FN,
+		RxAltFuncSelector:	UART_ALT_FN,
+	}
+	DefaultUART	= UART1
+)
+```
+
+
+
+```go
+var (
+	// I2C1 is documented, alias to I2C0 as well
+	I2C1	= &I2C{
+		Bus:			stm32.I2C1,
+		AltFuncSelector:	4,
+	}
+	I2C0	= I2C1
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	TIM1	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM1EN,
+		Device:		stm32.TIM1,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA8, AF1_TIM1_2_5_8_LPTIM1}, {PE9, AF1_TIM1_2_5_8_LPTIM1}}},
+			TimerChannel{Pins: []PinFunction{{PA9, AF1_TIM1_2_5_8_LPTIM1}, {PE11, AF1_TIM1_2_5_8_LPTIM1}}},
+			TimerChannel{Pins: []PinFunction{{PA10, AF1_TIM1_2_5_8_LPTIM1}, {PE13, AF1_TIM1_2_5_8_LPTIM1}}},
+			TimerChannel{Pins: []PinFunction{{PA11, AF1_TIM1_2_5_8_LPTIM1}, {PE14, AF1_TIM1_2_5_8_LPTIM1}}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM2	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR1,
+		EnableFlag:	stm32.RCC_APB1ENR1_TIM2EN,
+		Device:		stm32.TIM2,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA0, AF1_TIM1_2_5_8_LPTIM1}, {PA5, AF1_TIM1_2_5_8_LPTIM1}, {PA15, AF1_TIM1_2_5_8_LPTIM1}}},
+			TimerChannel{Pins: []PinFunction{{PA1, AF1_TIM1_2_5_8_LPTIM1}, {PB3, AF1_TIM1_2_5_8_LPTIM1}}},
+			TimerChannel{Pins: []PinFunction{{PA2, AF1_TIM1_2_5_8_LPTIM1}, {PB10, AF1_TIM1_2_5_8_LPTIM1}}},
+			TimerChannel{Pins: []PinFunction{{PA3, AF1_TIM1_2_5_8_LPTIM1}, {PB11, AF1_TIM1_2_5_8_LPTIM1}}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM3	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR1,
+		EnableFlag:	stm32.RCC_APB1ENR1_TIM3EN,
+		Device:		stm32.TIM3,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA6, AF2_TIM1_2_3_4_5_LPTIM3}, {PB4, AF2_TIM1_2_3_4_5_LPTIM3}, {PC6, AF2_TIM1_2_3_4_5_LPTIM3}, {PE3, AF2_TIM1_2_3_4_5_LPTIM3}}},
+			TimerChannel{Pins: []PinFunction{{PA7, AF2_TIM1_2_3_4_5_LPTIM3}, {PB5, AF2_TIM1_2_3_4_5_LPTIM3}, {PC7, AF2_TIM1_2_3_4_5_LPTIM3}, {PE4, AF2_TIM1_2_3_4_5_LPTIM3}}},
+			TimerChannel{Pins: []PinFunction{{PB0, AF2_TIM1_2_3_4_5_LPTIM3}, {PC8, AF2_TIM1_2_3_4_5_LPTIM3}, {PE5, AF2_TIM1_2_3_4_5_LPTIM3}}},
+			TimerChannel{Pins: []PinFunction{{PB1, AF2_TIM1_2_3_4_5_LPTIM3}, {PC9, AF2_TIM1_2_3_4_5_LPTIM3}, {PE6, AF2_TIM1_2_3_4_5_LPTIM3}}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM4	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR1,
+		EnableFlag:	stm32.RCC_APB1ENR1_TIM4EN,
+		Device:		stm32.TIM4,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PB6, AF2_TIM1_2_3_4_5_LPTIM3}, {PD12, AF2_TIM1_2_3_4_5_LPTIM3}}},
+			TimerChannel{Pins: []PinFunction{{PB7, AF2_TIM1_2_3_4_5_LPTIM3}, {PD13, AF2_TIM1_2_3_4_5_LPTIM3}}},
+			TimerChannel{Pins: []PinFunction{{PB8, AF2_TIM1_2_3_4_5_LPTIM3}, {PD14, AF2_TIM1_2_3_4_5_LPTIM3}}},
+			TimerChannel{Pins: []PinFunction{{PB9, AF2_TIM1_2_3_4_5_LPTIM3}, {PD15, AF2_TIM1_2_3_4_5_LPTIM3}}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM5	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR1,
+		EnableFlag:	stm32.RCC_APB1ENR1_TIM5EN,
+		Device:		stm32.TIM5,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA0, AF2_TIM1_2_3_4_5_LPTIM3}, {PF6, AF2_TIM1_2_3_4_5_LPTIM3}}},
+			TimerChannel{Pins: []PinFunction{{PA1, AF2_TIM1_2_3_4_5_LPTIM3}, {PF7, AF2_TIM1_2_3_4_5_LPTIM3}}},
+			TimerChannel{Pins: []PinFunction{{PA2, AF2_TIM1_2_3_4_5_LPTIM3}, {PF8, AF2_TIM1_2_3_4_5_LPTIM3}}},
+			TimerChannel{Pins: []PinFunction{{PA3, AF2_TIM1_2_3_4_5_LPTIM3}, {PF9, AF2_TIM1_2_3_4_5_LPTIM3}}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM6	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR1,
+		EnableFlag:	stm32.RCC_APB1ENR1_TIM6EN,
+		Device:		stm32.TIM6,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM7	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR1,
+		EnableFlag:	stm32.RCC_APB1ENR1_TIM7EN,
+		Device:		stm32.TIM7,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM8	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM8EN,
+		Device:		stm32.TIM8,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PC6, AF3_SPI2_SAI1_I2C4_USART2_TIM1_8_OCTOSPI1}}},
+			TimerChannel{Pins: []PinFunction{{PC7, AF3_SPI2_SAI1_I2C4_USART2_TIM1_8_OCTOSPI1}}},
+			TimerChannel{Pins: []PinFunction{{PC8, AF3_SPI2_SAI1_I2C4_USART2_TIM1_8_OCTOSPI1}}},
+			TimerChannel{Pins: []PinFunction{{PC9, AF3_SPI2_SAI1_I2C4_USART2_TIM1_8_OCTOSPI1}}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM15	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM15EN,
+		Device:		stm32.TIM15,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA1, AF14_TIM2_8_15_16_17_LPTIM2}, {PB14, AF14_TIM2_8_15_16_17_LPTIM2}, {PF9, AF14_TIM2_8_15_16_17_LPTIM2}, {PG10, AF14_TIM2_8_15_16_17_LPTIM2}}},
+			TimerChannel{Pins: []PinFunction{{PA2, AF14_TIM2_8_15_16_17_LPTIM2}, {PB15, AF14_TIM2_8_15_16_17_LPTIM2}, {PF10, AF14_TIM2_8_15_16_17_LPTIM2}, {PG11, AF14_TIM2_8_15_16_17_LPTIM2}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM16	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM16EN,
+		Device:		stm32.TIM16,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA6, AF14_TIM2_8_15_16_17_LPTIM2}, {PB8, AF14_TIM2_8_15_16_17_LPTIM2}, {PE0, AF14_TIM2_8_15_16_17_LPTIM2}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM17	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM17EN,
+		Device:		stm32.TIM17,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA7, AF14_TIM2_8_15_16_17_LPTIM2}, {PB9, AF14_TIM2_8_15_16_17_LPTIM2}, {PE1, AF14_TIM2_8_15_16_17_LPTIM2}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+)
+```
+
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself.
+
+The length of the device ID for STM32 is 12 bytes (96 bits).
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of cryptographically secure random data
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type ChannelCallback
+
+```go
+type ChannelCallback func(channel uint8)
+```
+
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*stm32.I2C_Type
+	AltFuncSelector	uint8
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration
+
+
+### func (Pin) ConfigureAltFunc
+
+```go
+func (p Pin) ConfigureAltFunc(config PinConfig, altFunc uint8)
+```
+
+Configure this pin with the given configuration including alternate
+
+	function mapping if necessary.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+PortMaskClear returns the register and mask to disable a given port. This can
+be used to implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+PortMaskSet returns the register and mask to enable a given GPIO pin. This
+can be used to implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetAltFunc
+
+```go
+func (p Pin) SetAltFunc(af uint8)
+```
+
+SetAltFunc maps the given alternative function to the I/O pin
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+---------- General pin operations ----------
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinFunction
+
+```go
+type PinFunction struct {
+	Pin	Pin
+	AltFunc	uint8
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type TIM
+
+```go
+type TIM struct {
+	EnableRegister	*volatile.Register32
+	EnableFlag	uint32
+	Device		*stm32.TIM_Type
+	Channels	[4]TimerChannel
+	UpInterrupt	interrupt.Interrupt
+	OCInterrupt	interrupt.Interrupt
+
+	wraparoundCallback	TimerCallback
+	channelCallbacks	[4]ChannelCallback
+
+	busFreq	uint64
+}
+```
+
+
+
+
+### func (*TIM) Channel
+
+```go
+func (t *TIM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*TIM) Configure
+
+```go
+func (t *TIM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+
+
+### func (*TIM) Count
+
+```go
+func (t *TIM) Count() uint32
+```
+
+
+
+### func (*TIM) Set
+
+```go
+func (t *TIM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	t.Set(ch, t.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*TIM) SetInverting
+
+```go
+func (t *TIM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TIM) SetMatchInterrupt
+
+```go
+func (t *TIM) SetMatchInterrupt(channel uint8, callback ChannelCallback) error
+```
+
+Sets a callback to be called when a channel reaches it's set-point.
+
+For example, if `t.Set(ch, t.Top() / 4)` is used then the callback will
+be called every quarter-period of the timer's base Period.
+
+
+### func (*TIM) SetPeriod
+
+```go
+func (t *TIM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TIM) SetWraparoundInterrupt
+
+```go
+func (t *TIM) SetWraparoundInterrupt(callback TimerCallback) error
+```
+
+SetWraparoundInterrupt configures a callback to be called each
+time the timer 'wraps-around'.
+
+For example, if `Configure(PWMConfig{Period:1000000})` is used,
+to set the timer period to 1ms, this callback will be called every
+1ms.
+
+
+### func (*TIM) Top
+
+```go
+func (t *TIM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+### func (*TIM) Unset
+
+```go
+func (t *TIM) Unset(channel uint8)
+```
+
+Unset disables a channel, including any configured interrupts.
+
+
+
+
+## type TimerCallback
+
+```go
+type TimerCallback func()
+```
+
+
+
+
+
+
+## type TimerChannel
+
+```go
+type TimerChannel struct {
+	Pins []PinFunction
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer			*RingBuffer
+	Bus			*stm32.USART_Type
+	Interrupt		interrupt.Interrupt
+	TxAltFuncSelector	uint8
+	RxAltFuncSelector	uint8
+
+	// Registers specific to the chip
+	rxReg		*volatile.Register32
+	txReg		*volatile.Register32
+	statusReg	*volatile.Register32
+	txEmptyFlag	uint32
+}
+```
+
+UART representation
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART. Defer to chip-specific
+routines for calculation
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/nucleo-wl55jc.md b/content/docs/reference/microcontrollers/machine/nucleo-wl55jc.md
new file mode 100644
index 00000000..7ddcb97c
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/nucleo-wl55jc.md
@@ -0,0 +1,1491 @@
+
+---
+title: nucleo-wl55jc
+---
+
+
+## Constants
+
+```go
+const (
+	LED_BLUE	= PB15
+	LED_GREEN	= PB9
+	LED_RED		= PB11
+	LED		= LED_RED
+
+	BTN1	= PA0
+	BTN2	= PA1
+	BTN3	= PC6
+	BUTTON	= BTN1
+
+	// SubGhz (SPI3)
+	SPI0_NSS_PIN	= PA4
+	SPI0_SCK_PIN	= PA5
+	SPI0_SDO_PIN	= PA6
+	SPI0_SDI_PIN	= PA7
+
+	//MCU USART1
+	UART1_TX_PIN	= PB6
+	UART1_RX_PIN	= PB7
+
+	//MCU USART2
+	UART2_RX_PIN	= PA3
+	UART2_TX_PIN	= PA2
+
+	// DEFAULT USART
+	UART_RX_PIN	= UART2_RX_PIN
+	UART_TX_PIN	= UART2_TX_PIN
+
+	// I2C1 pins
+	I2C1_SCL_PIN	= PA9
+	I2C1_SDA_PIN	= PA10
+	I2C1_ALT_FUNC	= 4
+
+	// I2C2 pins
+	I2C2_SCL_PIN	= PA12
+	I2C2_SDA_PIN	= PA11
+	I2C2_ALT_FUNC	= 4
+
+	// I2C0 alias for I2C1
+	I2C0_SDA_PIN	= I2C1_SDA_PIN
+	I2C0_SCL_PIN	= I2C1_SCL_PIN
+)
+```
+
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinRising	PinChange	= 1 << iota
+	PinFalling
+	PinToggle	= PinRising | PinFalling
+)
+```
+
+
+
+```go
+const (
+	MAX_NBYTE_SIZE	= 255
+
+	// 100ms delay = 100e6ns / 16ns
+	// In runtime_stm32_timers.go, tick is fixed at 16ns per tick
+	TIMEOUT_TICKS	= 100e6 / 16
+
+	I2C_NO_STARTSTOP		= 0x0
+	I2C_GENERATE_START_WRITE	= 0x80000000 | stm32.I2C_CR2_START
+	I2C_GENERATE_START_READ		= 0x80000000 | stm32.I2C_CR2_START | stm32.I2C_CR2_RD_WRN
+	I2C_GENERATE_STOP		= 0x80000000 | stm32.I2C_CR2_STOP
+)
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (32.768s)
+	//
+	// Timeout is based on 12-bit counter with /256 divider on
+	// 32.768kHz clock.  See 21.3.3 of RM0090 for table.
+	WatchdogMaxTimeout = ((0xfff + 1) * 256 * 1024) / 32768
+)
+```
+
+
+
+```go
+const (
+	// Mode Flag
+	PinOutput		PinMode	= 0
+	PinInput		PinMode	= PinInputFloating
+	PinInputFloating	PinMode	= 1
+	PinInputPulldown	PinMode	= 2
+	PinInputPullup		PinMode	= 3
+
+	// for UART
+	PinModeUARTTX	PinMode	= 4
+	PinModeUARTRX	PinMode	= 5
+
+	// for I2C
+	PinModeI2CSCL	PinMode	= 6
+	PinModeI2CSDA	PinMode	= 7
+
+	// for SPI
+	PinModeSPICLK	PinMode	= 8
+	PinModeSPISDO	PinMode	= 9
+	PinModeSPISDI	PinMode	= 10
+
+	// for analog/ADC
+	PinInputAnalog	PinMode	= 11
+
+	// for PWM
+	PinModePWMOutput	PinMode	= 12
+)
+```
+
+
+
+```go
+const RNG_MAX_READ_RETRIES = 1000
+```
+
+
+
+```go
+const PWM_MODE1 = 0x6
+```
+
+
+
+```go
+const (
+	AF0_SYSTEM		= 0
+	AF1_TIM1_2_LPTIM1	= 1
+	AF2_TIM1_2		= 2
+	AF3_SPIS2_TIM1_LPTIM3	= 3
+	AF4_I2C1_2_3		= 4
+	AF5_SPI1_SPI2S2		= 5
+	AF6_RF			= 6
+	AF7_USART1_2		= 7
+	AF8_LPUART1		= 8
+	AF12_COMP1_2_TIM1	= 12
+	AF13_DEBUG		= 13
+	AF14_TIM2_16_17_LPTIM2	= 14
+	AF15_EVENTOUT		= 15
+)
+```
+
+
+
+```go
+const (
+	SYSCLK		= 48e6
+	APB1_TIM_FREQ	= SYSCLK
+	APB2_TIM_FREQ	= SYSCLK
+)
+```
+
+
+
+```go
+const (
+	PA0	= portA + 0
+	PA1	= portA + 1
+	PA2	= portA + 2
+	PA3	= portA + 3
+	PA4	= portA + 4
+	PA5	= portA + 5
+	PA6	= portA + 6
+	PA7	= portA + 7
+	PA8	= portA + 8
+	PA9	= portA + 9
+	PA10	= portA + 10
+	PA11	= portA + 11
+	PA12	= portA + 12
+	PA13	= portA + 13
+	PA14	= portA + 14
+	PA15	= portA + 15
+
+	PB0	= portB + 0
+	PB1	= portB + 1
+	PB2	= portB + 2
+	PB3	= portB + 3
+	PB4	= portB + 4
+	PB5	= portB + 5
+	PB6	= portB + 6
+	PB7	= portB + 7
+	PB8	= portB + 8
+	PB9	= portB + 9
+	PB10	= portB + 10
+	PB11	= portB + 11
+	PB12	= portB + 12
+	PB13	= portB + 13
+	PB14	= portB + 14
+	PB15	= portB + 15
+
+	PC0	= portC + 0
+	PC1	= portC + 1
+	PC2	= portC + 2
+	PC3	= portC + 3
+	PC4	= portC + 4
+	PC5	= portC + 5
+	PC6	= portC + 6
+	PC7	= portC + 7
+	PC8	= portC + 8
+	PC9	= portC + 9
+	PC10	= portC + 10
+	PC11	= portC + 11
+	PC12	= portC + 12
+	PC13	= portC + 13
+	PC14	= portC + 14
+	PC15	= portC + 15
+
+	PH3	= portH + 3
+)
+```
+
+
+
+```go
+const (
+	ARR_MAX	= 0x10000
+	PSC_MAX	= 0x10000
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	// STM32 UART2 is connected to the embedded STLINKV3 Virtual Com Port
+	UART0	= &_UART0
+	_UART0	= UART{
+		Buffer:			NewRingBuffer(),
+		Bus:			stm32.USART2,
+		TxAltFuncSelector:	7,
+		RxAltFuncSelector:	7,
+	}
+
+	// UART1 is free
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:			NewRingBuffer(),
+		Bus:			stm32.USART1,
+		TxAltFuncSelector:	7,
+		RxAltFuncSelector:	7,
+	}
+
+	DefaultUART	= UART0
+
+	// I2C Busses
+	I2C1	= &I2C{
+		Bus:			stm32.I2C1,
+		AltFuncSelector:	I2C1_ALT_FUNC,
+	}
+	I2C2	= &I2C{
+		Bus:			stm32.I2C2,
+		AltFuncSelector:	I2C2_ALT_FUNC,
+	}
+	I2C0	= I2C1
+
+	// SPI
+	SPI3	= &SPI{
+		Bus: stm32.SPI3,
+	}
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	TIM1	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM1EN,
+		Device:		stm32.TIM1,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA8, AF1_TIM1_2_LPTIM1}}},
+			TimerChannel{Pins: []PinFunction{{PA9, AF1_TIM1_2_LPTIM1}}},
+			TimerChannel{Pins: []PinFunction{{PA10, AF1_TIM1_2_LPTIM1}}},
+			TimerChannel{Pins: []PinFunction{{PA11, AF1_TIM1_2_LPTIM1}}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+	TIM2	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR1,
+		EnableFlag:	stm32.RCC_APB1ENR1_TIM2EN,
+		Device:		stm32.TIM2,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA0, AF1_TIM1_2_LPTIM1}, {PA5, AF1_TIM1_2_LPTIM1}, {PA15, AF1_TIM1_2_LPTIM1}}},
+			TimerChannel{Pins: []PinFunction{{PA1, AF1_TIM1_2_LPTIM1}, {PB3, AF1_TIM1_2_LPTIM1}}},
+			TimerChannel{Pins: []PinFunction{{PA2, AF1_TIM1_2_LPTIM1}, {PB10, AF1_TIM1_2_LPTIM1}}},
+			TimerChannel{Pins: []PinFunction{{PA3, AF1_TIM1_2_LPTIM1}, {PB11, AF1_TIM1_2_LPTIM1}}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+	TIM16	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM16EN,
+		Device:		stm32.TIM16,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA6, AF14_TIM2_16_17_LPTIM2}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+	TIM17	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM17EN,
+		Device:		stm32.TIM17,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA7, AF1_TIM1_2_LPTIM1}, {PB9, AF1_TIM1_2_LPTIM1}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+)
+```
+
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself.
+
+The length of the device ID for STM32 is 12 bytes (96 bits).
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of cryptographically secure random data
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type ChannelCallback
+
+```go
+type ChannelCallback func(channel uint8)
+```
+
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*stm32.I2C_Type
+	AltFuncSelector	uint8
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration
+
+
+### func (Pin) ConfigureAltFunc
+
+```go
+func (p Pin) ConfigureAltFunc(config PinConfig, altFunc uint8)
+```
+
+Configure this pin with the given configuration including alternate
+
+	function mapping if necessary.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+PortMaskClear returns the register and mask to disable a given port. This can
+be used to implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+PortMaskSet returns the register and mask to enable a given GPIO pin. This
+can be used to implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetAltFunc
+
+```go
+func (p Pin) SetAltFunc(af uint8)
+```
+
+SetAltFunc maps the given alternative function to the I/O pin
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+---------- General pin operations ----------
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinFunction
+
+```go
+type PinFunction struct {
+	Pin	Pin
+	AltFunc	uint8
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus		*stm32.SPI_Type
+	AltFuncSelector	uint8
+}
+```
+
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the STM32 SPI1 interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type TIM
+
+```go
+type TIM struct {
+	EnableRegister	*volatile.Register32
+	EnableFlag	uint32
+	Device		*stm32.TIM_Type
+	Channels	[4]TimerChannel
+	UpInterrupt	interrupt.Interrupt
+	OCInterrupt	interrupt.Interrupt
+
+	wraparoundCallback	TimerCallback
+	channelCallbacks	[4]ChannelCallback
+
+	busFreq	uint64
+}
+```
+
+
+
+
+### func (*TIM) Channel
+
+```go
+func (t *TIM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*TIM) Configure
+
+```go
+func (t *TIM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+
+
+### func (*TIM) Count
+
+```go
+func (t *TIM) Count() uint32
+```
+
+
+
+### func (*TIM) Set
+
+```go
+func (t *TIM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	t.Set(ch, t.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*TIM) SetInverting
+
+```go
+func (t *TIM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TIM) SetMatchInterrupt
+
+```go
+func (t *TIM) SetMatchInterrupt(channel uint8, callback ChannelCallback) error
+```
+
+Sets a callback to be called when a channel reaches it's set-point.
+
+For example, if `t.Set(ch, t.Top() / 4)` is used then the callback will
+be called every quarter-period of the timer's base Period.
+
+
+### func (*TIM) SetPeriod
+
+```go
+func (t *TIM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TIM) SetWraparoundInterrupt
+
+```go
+func (t *TIM) SetWraparoundInterrupt(callback TimerCallback) error
+```
+
+SetWraparoundInterrupt configures a callback to be called each
+time the timer 'wraps-around'.
+
+For example, if `Configure(PWMConfig{Period:1000000})` is used,
+to set the timer period to 1ms, this callback will be called every
+1ms.
+
+
+### func (*TIM) Top
+
+```go
+func (t *TIM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+### func (*TIM) Unset
+
+```go
+func (t *TIM) Unset(channel uint8)
+```
+
+Unset disables a channel, including any configured interrupts.
+
+
+
+
+## type TimerCallback
+
+```go
+type TimerCallback func()
+```
+
+
+
+
+
+
+## type TimerChannel
+
+```go
+type TimerChannel struct {
+	Pins []PinFunction
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer			*RingBuffer
+	Bus			*stm32.USART_Type
+	Interrupt		interrupt.Interrupt
+	TxAltFuncSelector	uint8
+	RxAltFuncSelector	uint8
+
+	// Registers specific to the chip
+	rxReg		*volatile.Register32
+	txReg		*volatile.Register32
+	statusReg	*volatile.Register32
+	txEmptyFlag	uint32
+}
+```
+
+UART representation
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART. Defer to chip-specific
+routines for calculation
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/p1am-100.md b/content/docs/reference/microcontrollers/machine/p1am-100.md
new file mode 100644
index 00000000..05b9716e
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/p1am-100.md
@@ -0,0 +1,1792 @@
+
+---
+title: p1am-100
+---
+
+
+## Constants
+
+```go
+const (
+	PA00	Pin	= 0	// peripherals: TCC2 channel 0, sercomI2CM1 SDA
+	PA01	Pin	= 1	// peripherals: TCC2 channel 1, sercomI2CM1 SCL
+	PA02	Pin	= 2
+	PA03	Pin	= 3
+	PA04	Pin	= 4	// peripherals: TCC0 channel 0
+	PA05	Pin	= 5	// peripherals: TCC0 channel 1
+	PA06	Pin	= 6	// peripherals: TCC1 channel 0
+	PA07	Pin	= 7	// peripherals: TCC1 channel 1
+	PA08	Pin	= 8	// peripherals: TCC0 channel 0, TCC1 channel 2, sercomI2CM0 SDA, sercomI2CM2 SDA
+	PA09	Pin	= 9	// peripherals: TCC0 channel 1, TCC1 channel 3, sercomI2CM0 SCL, sercomI2CM2 SCL
+	PA10	Pin	= 10	// peripherals: TCC1 channel 0, TCC0 channel 2
+	PA11	Pin	= 11	// peripherals: TCC1 channel 1, TCC0 channel 3
+	PA12	Pin	= 12	// peripherals: TCC2 channel 0, TCC0 channel 2, sercomI2CM2 SDA, sercomI2CM4 SDA
+	PA13	Pin	= 13	// peripherals: TCC2 channel 1, TCC0 channel 3, sercomI2CM2 SCL, sercomI2CM4 SCL
+	PA14	Pin	= 14	// peripherals: TCC0 channel 0
+	PA15	Pin	= 15	// peripherals: TCC0 channel 1
+	PA16	Pin	= 16	// peripherals: TCC2 channel 0, TCC0 channel 2, sercomI2CM1 SDA, sercomI2CM3 SDA
+	PA17	Pin	= 17	// peripherals: TCC2 channel 1, TCC0 channel 3, sercomI2CM1 SCL, sercomI2CM3 SCL
+	PA18	Pin	= 18	// peripherals: TCC0 channel 2
+	PA19	Pin	= 19	// peripherals: TCC0 channel 3
+	PA20	Pin	= 20	// peripherals: TCC0 channel 2
+	PA21	Pin	= 21	// peripherals: TCC0 channel 3
+	PA22	Pin	= 22	// peripherals: TCC0 channel 0, sercomI2CM3 SDA, sercomI2CM5 SDA
+	PA23	Pin	= 23	// peripherals: TCC0 channel 1, sercomI2CM3 SCL, sercomI2CM5 SCL
+	PA24	Pin	= 24	// peripherals: TCC1 channel 2
+	PA25	Pin	= 25	// peripherals: TCC1 channel 3
+	PA26	Pin	= 26
+	PA27	Pin	= 27
+	PA28	Pin	= 28
+	PA29	Pin	= 29
+	PA30	Pin	= 30	// peripherals: TCC1 channel 0
+	PA31	Pin	= 31	// peripherals: TCC1 channel 1
+	PB00	Pin	= 32
+	PB01	Pin	= 33
+	PB02	Pin	= 34	// peripherals: sercomI2CM5 SDA
+	PB03	Pin	= 35	// peripherals: sercomI2CM5 SCL
+	PB04	Pin	= 36
+	PB05	Pin	= 37
+	PB06	Pin	= 38
+	PB07	Pin	= 39
+	PB08	Pin	= 40	// peripherals: sercomI2CM4 SDA
+	PB09	Pin	= 41	// peripherals: sercomI2CM4 SCL
+	PB10	Pin	= 42	// peripherals: TCC0 channel 0
+	PB11	Pin	= 43	// peripherals: TCC0 channel 1
+	PB12	Pin	= 44	// peripherals: TCC0 channel 2, sercomI2CM4 SDA
+	PB13	Pin	= 45	// peripherals: TCC0 channel 3, sercomI2CM4 SCL
+	PB14	Pin	= 46
+	PB15	Pin	= 47
+	PB16	Pin	= 48	// peripherals: TCC0 channel 0, sercomI2CM5 SDA
+	PB17	Pin	= 49	// peripherals: TCC0 channel 1, sercomI2CM5 SCL
+	PB18	Pin	= 50
+	PB19	Pin	= 51
+	PB20	Pin	= 52
+	PB21	Pin	= 53
+	PB22	Pin	= 54
+	PB23	Pin	= 55
+	PB24	Pin	= 56
+	PB25	Pin	= 57
+	PB26	Pin	= 58
+	PB27	Pin	= 59
+	PB28	Pin	= 60
+	PB29	Pin	= 61
+	PB30	Pin	= 62	// peripherals: TCC0 channel 0, TCC1 channel 2, sercomI2CM5 SDA
+	PB31	Pin	= 63	// peripherals: TCC0 channel 1, TCC1 channel 3, sercomI2CM5 SCL
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	D0	Pin	= PA22	// PWM available
+	D1	Pin	= PA23	// PWM available
+	D2	Pin	= PA10	// PWM available
+	D3	Pin	= PA11	// PWM available
+	D4	Pin	= PB10	// PWM available
+	D5	Pin	= PB11	// PWM available
+	D6	Pin	= PA20	// PWM available
+	D7	Pin	= PA21	// PWM available
+
+	D8	Pin	= PA16	// PWM available
+	D9	Pin	= PA17
+	D10	Pin	= PA19	// PWM available
+	D11	Pin	= PA08
+	D12	Pin	= PA09
+	D13	Pin	= PB23
+	D14	Pin	= PB22
+
+	// Remaining pins are shared with analog pins
+	D15	Pin	= PA02
+
+	D16	Pin	= PB02
+	D17	Pin	= PB03
+	D18	Pin	= PA04	// PWM available
+	D19	Pin	= PA05	// PWM available
+	D20	Pin	= PA06
+	D21	Pin	= PA07
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A0	Pin	= PA02	// ADC/AIN[0]
+	A1	Pin	= PB02	// ADC/AIN[10]
+	A2	Pin	= PB03	// ADC/AIN[11]
+	A3	Pin	= PA04	// ADC/AIN[4]
+	A4	Pin	= PA05	// ADC/AIN[5]
+	A5	Pin	= PA06	// ADC/AIN[6]
+	A6	Pin	= PA07	// ADC/AIN[7]
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	SWITCH		Pin	= PA28
+	LED		Pin	= PB08
+	ADC_BATTERY	Pin	= PB09	// ADC/AIN[3]
+)
+```
+
+
+
+```go
+const (
+	BASE_SLAVE_SELECT_PIN	Pin	= A3
+	BASE_SLAVE_ACK_PIN	Pin	= A4
+	BASE_ENABLE_PIN		Pin	= PB09
+)
+```
+
+P1AM Base Controller
+
+
+```go
+const (
+	USBCDC_DM_PIN		Pin	= PA24
+	USBCDC_DP_PIN		Pin	= PA25
+	USBCDC_HOST_ENABLE_PIN	Pin	= PA18
+)
+```
+
+USBCDC pins
+
+
+```go
+const (
+	UART_RX_PIN	Pin	= PB23	// RX: SERCOM5/PAD[3]
+	UART_TX_PIN	Pin	= PB22	// TX: SERCOM5/PAD[2]
+)
+```
+
+UART1 pins
+
+
+```go
+const (
+	SDA_PIN	Pin	= PA08	// SDA:  SERCOM0/PAD[0]
+	SCL_PIN	Pin	= PA09	// SCL:  SERCOM0/PAD[1]
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	Pin	= D9	// SCK: SERCOM1/PAD[1]
+	SPI0_SDO_PIN	Pin	= D8	// SDO: SERCOM1/PAD[0]
+	SPI0_SDI_PIN	Pin	= D10	// SDI: SERCOM1/PAD[3]
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	SDCARD_SDI_PIN	Pin	= PA15	// SDI: SERCOM2/PAD[3]
+	SDCARD_SDO_PIN	Pin	= PA12	// SDO: SERCOM2/PAD[0]
+	SDCARD_SCK_PIN	Pin	= PA13	// SCK: SERCOM2/PAD[1]
+	SDCARD_SS_PIN	Pin	= PA14	// SS: as GPIO
+	SDCARD_CD_PIN	Pin	= PA27
+)
+```
+
+SD card pins
+
+
+```go
+const (
+	I2S_SCK_PIN	Pin	= D2
+	I2S_SDO_PIN	Pin	= A6
+	I2S_SDI_PIN		= NoPin
+	I2S_WS_PIN		= D3
+)
+```
+
+I2S pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const (
+	I2SModeSource	I2SMode	= iota
+	I2SModeReceiver
+	I2SModePDM
+	I2SModeSourceReceiver
+)
+```
+
+
+
+```go
+const (
+	I2StandardPhilips	I2SStandard	= iota
+	I2SStandardMSB
+	I2SStandardLSB
+)
+```
+
+
+
+```go
+const (
+	I2SClockSourceInternal	I2SClockSource	= iota
+	I2SClockSourceExternal
+)
+```
+
+
+
+```go
+const (
+	I2SDataFormatDefault	I2SDataFormat	= 0
+	I2SDataFormat8bit			= 8
+	I2SDataFormat16bit			= 16
+	I2SDataFormat24bit			= 24
+	I2SDataFormat32bit			= 32
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinAnalog	PinMode	= 1
+	PinSERCOM	PinMode	= 2
+	PinSERCOMAlt	PinMode	= 3
+	PinTimer	PinMode	= 4
+	PinTimerAlt	PinMode	= 5
+	PinCom		PinMode	= 6
+	//PinAC_CLK        PinMode = 7
+	PinDigital		PinMode	= 8
+	PinInput		PinMode	= 9
+	PinInputPullup		PinMode	= 10
+	PinOutput		PinMode	= 11
+	PinTCC			PinMode	= PinTimer
+	PinTCCAlt		PinMode	= PinTimerAlt
+	PinInputPulldown	PinMode	= 12
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
+	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
+	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (16s)
+	WatchdogMaxTimeout = (16384 * 1000) / 1024
+)
+```
+
+
+
+```go
+const (
+	// these are SAMD21 specific.
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Pos	= 0
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Mask	= 0x3FFF
+
+	usb_DEVICE_PCKSIZE_SIZE_Pos	= 28
+	usb_DEVICE_PCKSIZE_SIZE_Mask	= 0x7
+
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Pos	= 14
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Mask	= 0x3FFF
+
+	NumberOfUSBEndpoints	= 8
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var UART1 = &sercomUSART5
+```
+
+UART1 on the P1AM-100 connects to the normal TX/RX pins.
+
+
+```go
+var (
+	I2C0 = sercomI2CM0
+)
+```
+
+I2C on the P1AM-100.
+
+
+```go
+var (
+	SPI0			= sercomSPIM1
+	BASE_CONTROLLER_SPI	= SPI0
+)
+```
+
+SPI on the P1AM-100 is used for Base Controller.
+
+
+```go
+var (
+	SPI1		= sercomSPIM2
+	SDCARD_SPI	= SPI1
+)
+```
+
+SPI1 is connected to the SD card slot on the P1AM-100
+
+
+```go
+var (
+	ErrInvalidSampleFrequency = errors.New("i2s: invalid sample frequency")
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var I2S0 = I2S{Bus: sam.I2S}
+```
+
+
+
+```go
+var (
+	TCC0	= (*TCC)(sam.TCC0)
+	TCC1	= (*TCC)(sam.TCC1)
+	TCC2	= (*TCC)(sam.TCC2)
+)
+```
+
+The SAM D21 has three TCC peripherals, which have PWM as one feature.
+
+
+```go
+var (
+	DAC0 = DAC{}
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the SAMD21.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+Return the current CPU frequency in hertz.
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) and 16 bytes (128 bits) are common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig)
+```
+
+Configure configures a ADC pin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type DAC
+
+```go
+type DAC struct {
+}
+```
+
+DAC on the SAMD21.
+
+
+
+### func (DAC) Configure
+
+```go
+func (dac DAC) Configure(config DACConfig)
+```
+
+Configure the DAC.
+output pin must already be configured.
+
+
+### func (DAC) Set
+
+```go
+func (dac DAC) Set(value uint16) error
+```
+
+Set writes a single 16-bit value to the DAC.
+Since the ATSAMD21 only has a 10-bit DAC, the passed-in value will be scaled down.
+
+
+
+
+## type DACConfig
+
+```go
+type DACConfig struct {
+}
+```
+
+DACConfig placeholder for future expansion.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*sam.SERCOM_I2CM_Type
+	SERCOM	uint8
+}
+```
+
+I2C on the SAMD21.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteByte
+
+```go
+func (i2c *I2C) WriteByte(data byte) error
+```
+
+WriteByte writes a single byte to the I2C bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type I2S
+
+```go
+type I2S struct {
+	Bus		*sam.I2S_Type
+	Frequency	uint32
+	DataFormat	I2SDataFormat
+}
+```
+
+I2S
+
+
+
+### func (*I2S) Configure
+
+```go
+func (i2s *I2S) Configure(config I2SConfig) error
+```
+
+Configure is used to configure the I2S interface. You must call this
+before you can use the I2S bus.
+
+
+### func (*I2S) Enable
+
+```go
+func (i2s *I2S) Enable(enabled bool)
+```
+
+Enabled is used to enable or disable the I2S bus.
+
+
+### func (*I2S) ReadMono
+
+```go
+func (i2s *I2S) ReadMono(p []uint16) (n int, err error)
+```
+
+Read mono data from the I2S bus into the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) ReadStereo
+
+```go
+func (i2s *I2S) ReadStereo(p []uint32) (n int, err error)
+```
+
+Read stereo data from the I2S bus into the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) SetSampleFrequency
+
+```go
+func (i2s *I2S) SetSampleFrequency(freq uint32) error
+```
+
+SetSampleFrequency is used to set the sample frequency for the I2S bus.
+
+
+### func (*I2S) WriteMono
+
+```go
+func (i2s *I2S) WriteMono(p []uint16) (n int, err error)
+```
+
+Write mono data to the I2S bus from the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) WriteStereo
+
+```go
+func (i2s *I2S) WriteStereo(p []uint32) (n int, err error)
+```
+
+Write stereo data to the I2S bus from the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+
+
+## type I2SClockSource
+
+```go
+type I2SClockSource uint8
+```
+
+
+
+
+
+
+## type I2SConfig
+
+```go
+type I2SConfig struct {
+	// clock
+	SCK	Pin
+	// word select
+	WS	Pin
+	// data out
+	SDO	Pin
+	// data in
+	SDI		Pin
+	Mode		I2SMode
+	Standard	I2SStandard
+	ClockSource	I2SClockSource
+	DataFormat	I2SDataFormat
+	AudioFrequency	uint32
+	MainClockOutput	bool
+	Stereo		bool
+}
+```
+
+All fields are optional and may not be required or used on a particular platform.
+
+
+
+
+
+## type I2SDataFormat
+
+```go
+type I2SDataFormat uint8
+```
+
+
+
+
+
+
+## type I2SMode
+
+```go
+type I2SMode uint8
+```
+
+
+
+
+
+
+## type I2SStandard
+
+```go
+type I2SStandard uint8
+```
+
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when configured as an input or as
+an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*sam.SERCOM_SPI_Type
+	SERCOM	uint8
+}
+```
+
+SPI
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type TCC
+
+```go
+type TCC sam.TCC_Type
+```
+
+TCC is one timer/counter peripheral, which consists of a counter and multiple
+output channels (that can be connected to actual pins). You can set the
+frequency using SetPeriod, but only for all the channels in this TCC
+peripheral at once.
+
+
+
+### func (*TCC) Channel
+
+```go
+func (tcc *TCC) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin. Note that one channel may be
+shared between multiple pins, and so will have the same duty cycle. If this
+is not desirable, look for a different TCC peripheral or consider using a
+different pin.
+
+
+### func (*TCC) Configure
+
+```go
+func (tcc *TCC) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this TCC.
+
+
+### func (*TCC) Counter
+
+```go
+func (tcc *TCC) Counter() uint32
+```
+
+Counter returns the current counter value of the timer in this TCC
+peripheral. It may be useful for debugging.
+
+
+### func (*TCC) Set
+
+```go
+func (tcc *TCC) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle, in other words the fraction of time the channel output is high (or low
+when inverted). For example, to set it to a 25% duty cycle, use:
+
+	tcc.Set(channel, tcc.Top() / 4)
+
+tcc.Set(channel, 0) will set the output to low and tcc.Set(channel,
+tcc.Top()) will set the output to high, assuming the output isn't inverted.
+
+
+### func (*TCC) SetInverting
+
+```go
+func (tcc *TCC) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TCC) SetPeriod
+
+```go
+func (tcc *TCC) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this TCC peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the TCC peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TCC) Top
+
+```go
+func (tcc *TCC) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to Set
+(see Set documentation for more information).
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*sam.SERCOM_USART_Type
+	SERCOM		uint8
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the SAMD21.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/particle-argon.md b/content/docs/reference/microcontrollers/machine/particle-argon.md
new file mode 100644
index 00000000..d34bafd6
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/particle-argon.md
@@ -0,0 +1,1568 @@
+
+---
+title: particle-argon
+---
+
+
+## Constants
+
+```go
+const (
+	P0_00	Pin	= 0
+	P0_01	Pin	= 1
+	P0_02	Pin	= 2
+	P0_03	Pin	= 3
+	P0_04	Pin	= 4
+	P0_05	Pin	= 5
+	P0_06	Pin	= 6
+	P0_07	Pin	= 7
+	P0_08	Pin	= 8
+	P0_09	Pin	= 9
+	P0_10	Pin	= 10
+	P0_11	Pin	= 11
+	P0_12	Pin	= 12
+	P0_13	Pin	= 13
+	P0_14	Pin	= 14
+	P0_15	Pin	= 15
+	P0_16	Pin	= 16
+	P0_17	Pin	= 17
+	P0_18	Pin	= 18
+	P0_19	Pin	= 19
+	P0_20	Pin	= 20
+	P0_21	Pin	= 21
+	P0_22	Pin	= 22
+	P0_23	Pin	= 23
+	P0_24	Pin	= 24
+	P0_25	Pin	= 25
+	P0_26	Pin	= 26
+	P0_27	Pin	= 27
+	P0_28	Pin	= 28
+	P0_29	Pin	= 29
+	P0_30	Pin	= 30
+	P0_31	Pin	= 31
+	P1_00	Pin	= 32
+	P1_01	Pin	= 33
+	P1_02	Pin	= 34
+	P1_03	Pin	= 35
+	P1_04	Pin	= 36
+	P1_05	Pin	= 37
+	P1_06	Pin	= 38
+	P1_07	Pin	= 39
+	P1_08	Pin	= 40
+	P1_09	Pin	= 41
+	P1_10	Pin	= 42
+	P1_11	Pin	= 43
+	P1_12	Pin	= 44
+	P1_13	Pin	= 45
+	P1_14	Pin	= 46
+	P1_15	Pin	= 47
+)
+```
+
+Hardware pins
+
+
+```go
+const HasLowFrequencyCrystal = true
+```
+
+
+
+```go
+const (
+	A0	Pin	= 3
+	A1	Pin	= 4
+	A2	Pin	= 28
+	A3	Pin	= 29
+	A4	Pin	= 30
+	A5	Pin	= 31
+	D0	Pin	= 26	// Also SDA
+	D1	Pin	= 27	// Also SCL
+	D2	Pin	= 33
+	D3	Pin	= 34
+	D4	Pin	= 40
+	D5	Pin	= 42
+	D6	Pin	= 43
+	D7	Pin	= 44	// Also LED
+	D8	Pin	= 35
+	D9	Pin	= 6	// Also TX
+	D10	Pin	= 8	// Also RX
+	D11	Pin	= 46	// Also SDI
+	D12	Pin	= 45	// Also SDO
+	D13	Pin	= 47	// Also SCK
+)
+```
+
+GPIOs
+
+
+```go
+const (
+	LED		Pin	= 44
+	LED_GREEN	Pin	= 14
+	LED_RED		Pin	= 13
+	LED_BLUE	Pin	= 15
+)
+```
+
+LEDs
+
+
+```go
+const (
+	UART_TX_PIN	Pin	= 6
+	UART_RX_PIN	Pin	= 8
+)
+```
+
+
+
+```go
+const (
+	SDA_PIN	Pin	= 26
+	SCL_PIN	Pin	= 27
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	Pin	= 47
+	SPI0_SDO_PIN	Pin	= 45
+	SPI0_SDI_PIN	Pin	= 46
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	SPI1_SCK_PIN	Pin	= 19
+	SPI1_SDO_PIN	Pin	= 20
+	SPI1_SDI_PIN	Pin	= 21
+	SPI1_CS_PIN	Pin	= 17
+	SPI1_WP_PIN	Pin	= 22
+	SPI1_HOLD_PIN	Pin	= 23
+)
+```
+
+Internal 4MB SPI Flash
+
+
+```go
+const (
+	ESP32_TXD_PIN		Pin	= 36
+	ESP32_RXD_PIN		Pin	= 37
+	ESP32_CTS_PIN		Pin	= 39
+	ESP32_RTS_PIN		Pin	= 38
+	ESP32_BOOT_MODE_PIN	Pin	= 16
+	ESP32_WIFI_EN_PIN	Pin	= 24
+	ESP32_HOST_WK_PIN	Pin	= 7
+)
+```
+
+ESP32 coprocessor
+
+
+```go
+const (
+	MODE_BUTTON_PIN		Pin	= 11
+	CHARGE_STATUS_PIN	Pin	= 41
+	LIPO_VOLTAGE_PIN	Pin	= 5
+	PCB_ANTENNA_PIN		Pin	= 2
+	EXTERNAL_UFL_PIN	Pin	= 25
+	NFC1_PIN		Pin	= 9
+	NFC2_PIN		Pin	= 10
+)
+```
+
+Other peripherals
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
+	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
+	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 36h)
+	WatchdogMaxTimeout = (0xffffffff * 1000) / 32768
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	DefaultUART = UART0
+)
+```
+
+UART
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	// UART0 is the hardware UART on the NRF SoC.
+	_UART0	= UART{Buffer: NewRingBuffer()}
+	UART0	= &_UART0
+)
+```
+
+UART
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	PWM0	= &PWM{PWM: nrf.PWM0}
+	PWM1	= &PWM{PWM: nrf.PWM1}
+	PWM2	= &PWM{PWM: nrf.PWM2}
+	PWM3	= &PWM{PWM: nrf.PWM3}
+)
+```
+
+PWM
+
+
+```go
+var (
+	I2C0	= &I2C{Bus: nrf.TWIM0, BusT: nrf.TWIS0}
+	I2C1	= &I2C{Bus: nrf.TWIM1, BusT: nrf.TWIS1}
+)
+```
+
+There are 2 I2C interfaces on the NRF.
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	SPI0	= &SPI{Bus: nrf.SPIM0, buf: new([1]byte)}
+	SPI1	= &SPI{Bus: nrf.SPIM1, buf: new([1]byte)}
+	SPI2	= &SPI{Bus: nrf.SPIM2, buf: new([1]byte)}
+)
+```
+
+There are 3 SPI interfaces on the NRF528xx.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader resets the chip into the serial bootloader.
+
+
+### func EnterOTABootloader
+
+```go
+func EnterOTABootloader()
+```
+
+EnterOTABootloader resets the chip into the bootloader so that it can be
+flashed via an OTA update
+
+
+### func EnterSerialBootloader
+
+```go
+func EnterSerialBootloader()
+```
+
+EnterSerialBootloader resets the chip into the serial bootloader. After
+reset, it can be flashed using serial/nrfutil.
+
+
+### func EnterUF2Bootloader
+
+```go
+func EnterUF2Bootloader()
+```
+
+EnterUF2Bootloader resets the chip into the UF2 bootloader. After reset, it
+can be flashed via nrfutil or by copying a UF2 file to the mass storage device
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (ret uint32, err error)
+```
+
+GetRNG returns 32 bits of non-deterministic random data based on internal thermal noise.
+According to Nordic's documentation, the random output is suitable for cryptographic purposes.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() int32
+```
+
+ReadTemperature reads the silicon die temperature of the chip. The return
+value is in milli-celsius.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USBHID (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (*ADC) Configure
+
+```go
+func (a *ADC) Configure(config ADCConfig)
+```
+
+Configure configures an ADC pin to be able to read analog data.
+Reference voltage can be 150, 300, 600, 1200, 1800, 2400, 3000(default), 3600 mV
+Resolution can be 8, 10, 12(default), 14 bits
+SampleTime will be ceiled to 3(default), 5, 10, 15, 20 or 40(max) µS respectively
+Samples can be 1(default), 2, 4, 8, 16, 32, 64, 128, 256 samples
+
+
+### func (*ADC) Get
+
+```go
+func (a *ADC) Get() uint16
+```
+
+Get returns the current value of an ADC pin in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*nrf.TWIM_Type	// Called Bus to align with Bus field in nrf51
+	BusT	*nrf.TWIS_Type
+	mode	I2CMode
+}
+```
+
+I2C on the NRF528xx.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint8) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+Reply supplies the response data the controller.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) (err error)
+```
+
+Tx does a single I2C transaction at the specified address (when in controller mode).
+
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+WaitForEvent blocks the current go-routine until an I2C event is received (when in Target mode).
+
+The passed buffer will be populated for receive events, with the number of bytes
+received returned in count.  For other event types, buf is not modified and a count
+of zero is returned.
+
+For request events, the caller MUST call `Reply` to avoid hanging the i2c bus indefinitely.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDM
+
+```go
+type PDM struct {
+	device		*nrf.PDM_Type
+	defaultBuffer	int16
+}
+```
+
+PDM represents a PDM device
+
+
+
+### func (*PDM) Configure
+
+```go
+func (pdm *PDM) Configure(config PDMConfig) error
+```
+
+Configure is intended to set up the PDM interface prior to use.
+
+
+### func (*PDM) Read
+
+```go
+func (pdm *PDM) Read(buf []int16) (uint32, error)
+```
+
+Read stores a set of samples in the given target buffer.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWM
+
+```go
+type PWM struct {
+	PWM	*nrf.PWM_Type
+
+	channelValues	[4]volatile.Register16
+}
+```
+
+PWM is one PWM peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this PWM peripheral at
+once.
+
+
+
+### func (*PWM) Channel
+
+```go
+func (pwm *PWM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*PWM) Configure
+
+```go
+func (pwm *PWM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+On the nRF52 series, the maximum period is around 0.26s.
+
+
+### func (*PWM) Set
+
+```go
+func (pwm *PWM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	ch.Set(ch.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*PWM) SetInverting
+
+```go
+func (pwm *PWM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*PWM) SetPeriod
+
+```go
+func (pwm *PWM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*PWM) Top
+
+```go
+func (pwm *PWM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*nrf.SPIM_Type
+	buf	*[1]byte	// 1-byte buffer for the Transfer method
+}
+```
+
+SPI on the NRF.
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to set up the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous
+write/read interface, there must always be the same number of bytes written
+as bytes read. Therefore, if the number of bytes don't match it will be
+padded until they fit: if len(w) > len(r) the extra bytes received will be
+dropped and if len(w) < len(r) extra 0 bytes will be sent.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer *RingBuffer
+}
+```
+
+UART on the NRF.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/particle-boron.md b/content/docs/reference/microcontrollers/machine/particle-boron.md
new file mode 100644
index 00000000..cb07c645
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/particle-boron.md
@@ -0,0 +1,1571 @@
+
+---
+title: particle-boron
+---
+
+
+## Constants
+
+```go
+const (
+	P0_00	Pin	= 0
+	P0_01	Pin	= 1
+	P0_02	Pin	= 2
+	P0_03	Pin	= 3
+	P0_04	Pin	= 4
+	P0_05	Pin	= 5
+	P0_06	Pin	= 6
+	P0_07	Pin	= 7
+	P0_08	Pin	= 8
+	P0_09	Pin	= 9
+	P0_10	Pin	= 10
+	P0_11	Pin	= 11
+	P0_12	Pin	= 12
+	P0_13	Pin	= 13
+	P0_14	Pin	= 14
+	P0_15	Pin	= 15
+	P0_16	Pin	= 16
+	P0_17	Pin	= 17
+	P0_18	Pin	= 18
+	P0_19	Pin	= 19
+	P0_20	Pin	= 20
+	P0_21	Pin	= 21
+	P0_22	Pin	= 22
+	P0_23	Pin	= 23
+	P0_24	Pin	= 24
+	P0_25	Pin	= 25
+	P0_26	Pin	= 26
+	P0_27	Pin	= 27
+	P0_28	Pin	= 28
+	P0_29	Pin	= 29
+	P0_30	Pin	= 30
+	P0_31	Pin	= 31
+	P1_00	Pin	= 32
+	P1_01	Pin	= 33
+	P1_02	Pin	= 34
+	P1_03	Pin	= 35
+	P1_04	Pin	= 36
+	P1_05	Pin	= 37
+	P1_06	Pin	= 38
+	P1_07	Pin	= 39
+	P1_08	Pin	= 40
+	P1_09	Pin	= 41
+	P1_10	Pin	= 42
+	P1_11	Pin	= 43
+	P1_12	Pin	= 44
+	P1_13	Pin	= 45
+	P1_14	Pin	= 46
+	P1_15	Pin	= 47
+)
+```
+
+Hardware pins
+
+
+```go
+const HasLowFrequencyCrystal = true
+```
+
+
+
+```go
+const (
+	A0	Pin	= 3
+	A1	Pin	= 4
+	A2	Pin	= 28
+	A3	Pin	= 29
+	A4	Pin	= 30
+	A5	Pin	= 31
+	D0	Pin	= 26	// Also SDA
+	D1	Pin	= 27	// Also SCL
+	D2	Pin	= 33
+	D3	Pin	= 34
+	D4	Pin	= 40
+	D5	Pin	= 42
+	D6	Pin	= 43
+	D7	Pin	= 44	// Also LED
+	D8	Pin	= 35
+	D9	Pin	= 6	// Also TX
+	D10	Pin	= 8	// Also RX
+	D11	Pin	= 46	// Also SDI
+	D12	Pin	= 45	// Also SDO
+	D13	Pin	= 47	// Also SCK
+)
+```
+
+GPIOs
+
+
+```go
+const (
+	LED		Pin	= 44
+	LED_GREEN	Pin	= 14
+	LED_RED		Pin	= 13
+	LED_BLUE	Pin	= 15
+)
+```
+
+LEDs
+
+
+```go
+const (
+	UART_TX_PIN	Pin	= 6
+	UART_RX_PIN	Pin	= 8
+)
+```
+
+
+
+```go
+const (
+	SDA_PIN	Pin	= 26
+	SCL_PIN	Pin	= 27
+
+	// Internal I2C with MAX17043 (Fuel gauge) and BQ24195 (Power management) chips on it
+	SDA1_PIN	Pin	= 24
+	SCL1_PIN	Pin	= 41
+	INT1_PIN	Pin	= 5
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	Pin	= 47
+	SPI0_SDO_PIN	Pin	= 45
+	SPI0_SDI_PIN	Pin	= 46
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	SPI1_SCK_PIN	Pin	= 19
+	SPI1_SDO_PIN	Pin	= 20
+	SPI1_SDI_PIN	Pin	= 21
+	SPI1_CS_PIN	Pin	= 17
+	SPI1_WP_PIN	Pin	= 22
+	SPI1_HOLD_PIN	Pin	= 23
+)
+```
+
+Internal 4MB SPI Flash
+
+
+```go
+const (
+	SARA_TXD_PIN		Pin	= 37
+	SARA_RXD_PIN		Pin	= 36
+	SARA_CTS_PIN		Pin	= 38
+	SARA_RTS_PIN		Pin	= 39
+	SARA_RESET_PIN		Pin	= 12
+	SARA_POWER_ON_PIN	Pin	= 16
+	SARA_BUFF_EN_PIN	Pin	= 25
+	SARA_VINT_PIN		Pin	= 2
+)
+```
+
+u-blox SARA coprocessor
+
+
+```go
+const (
+	MODE_BUTTON_PIN	Pin	= 11
+	ANTENNA_SEL_PIN	Pin	= 7	// Low: chip antenna, High: External uFL
+	NFC1_PIN	Pin	= 9
+	NFC2_PIN	Pin	= 10
+)
+```
+
+Other peripherals
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
+	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
+	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 36h)
+	WatchdogMaxTimeout = (0xffffffff * 1000) / 32768
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	DefaultUART = UART0
+)
+```
+
+UART
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	// UART0 is the hardware UART on the NRF SoC.
+	_UART0	= UART{Buffer: NewRingBuffer()}
+	UART0	= &_UART0
+)
+```
+
+UART
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	PWM0	= &PWM{PWM: nrf.PWM0}
+	PWM1	= &PWM{PWM: nrf.PWM1}
+	PWM2	= &PWM{PWM: nrf.PWM2}
+	PWM3	= &PWM{PWM: nrf.PWM3}
+)
+```
+
+PWM
+
+
+```go
+var (
+	I2C0	= &I2C{Bus: nrf.TWIM0, BusT: nrf.TWIS0}
+	I2C1	= &I2C{Bus: nrf.TWIM1, BusT: nrf.TWIS1}
+)
+```
+
+There are 2 I2C interfaces on the NRF.
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	SPI0	= &SPI{Bus: nrf.SPIM0, buf: new([1]byte)}
+	SPI1	= &SPI{Bus: nrf.SPIM1, buf: new([1]byte)}
+	SPI2	= &SPI{Bus: nrf.SPIM2, buf: new([1]byte)}
+)
+```
+
+There are 3 SPI interfaces on the NRF528xx.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader resets the chip into the serial bootloader.
+
+
+### func EnterOTABootloader
+
+```go
+func EnterOTABootloader()
+```
+
+EnterOTABootloader resets the chip into the bootloader so that it can be
+flashed via an OTA update
+
+
+### func EnterSerialBootloader
+
+```go
+func EnterSerialBootloader()
+```
+
+EnterSerialBootloader resets the chip into the serial bootloader. After
+reset, it can be flashed using serial/nrfutil.
+
+
+### func EnterUF2Bootloader
+
+```go
+func EnterUF2Bootloader()
+```
+
+EnterUF2Bootloader resets the chip into the UF2 bootloader. After reset, it
+can be flashed via nrfutil or by copying a UF2 file to the mass storage device
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (ret uint32, err error)
+```
+
+GetRNG returns 32 bits of non-deterministic random data based on internal thermal noise.
+According to Nordic's documentation, the random output is suitable for cryptographic purposes.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() int32
+```
+
+ReadTemperature reads the silicon die temperature of the chip. The return
+value is in milli-celsius.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USBHID (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (*ADC) Configure
+
+```go
+func (a *ADC) Configure(config ADCConfig)
+```
+
+Configure configures an ADC pin to be able to read analog data.
+Reference voltage can be 150, 300, 600, 1200, 1800, 2400, 3000(default), 3600 mV
+Resolution can be 8, 10, 12(default), 14 bits
+SampleTime will be ceiled to 3(default), 5, 10, 15, 20 or 40(max) µS respectively
+Samples can be 1(default), 2, 4, 8, 16, 32, 64, 128, 256 samples
+
+
+### func (*ADC) Get
+
+```go
+func (a *ADC) Get() uint16
+```
+
+Get returns the current value of an ADC pin in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*nrf.TWIM_Type	// Called Bus to align with Bus field in nrf51
+	BusT	*nrf.TWIS_Type
+	mode	I2CMode
+}
+```
+
+I2C on the NRF528xx.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint8) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+Reply supplies the response data the controller.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) (err error)
+```
+
+Tx does a single I2C transaction at the specified address (when in controller mode).
+
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+WaitForEvent blocks the current go-routine until an I2C event is received (when in Target mode).
+
+The passed buffer will be populated for receive events, with the number of bytes
+received returned in count.  For other event types, buf is not modified and a count
+of zero is returned.
+
+For request events, the caller MUST call `Reply` to avoid hanging the i2c bus indefinitely.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDM
+
+```go
+type PDM struct {
+	device		*nrf.PDM_Type
+	defaultBuffer	int16
+}
+```
+
+PDM represents a PDM device
+
+
+
+### func (*PDM) Configure
+
+```go
+func (pdm *PDM) Configure(config PDMConfig) error
+```
+
+Configure is intended to set up the PDM interface prior to use.
+
+
+### func (*PDM) Read
+
+```go
+func (pdm *PDM) Read(buf []int16) (uint32, error)
+```
+
+Read stores a set of samples in the given target buffer.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWM
+
+```go
+type PWM struct {
+	PWM	*nrf.PWM_Type
+
+	channelValues	[4]volatile.Register16
+}
+```
+
+PWM is one PWM peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this PWM peripheral at
+once.
+
+
+
+### func (*PWM) Channel
+
+```go
+func (pwm *PWM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*PWM) Configure
+
+```go
+func (pwm *PWM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+On the nRF52 series, the maximum period is around 0.26s.
+
+
+### func (*PWM) Set
+
+```go
+func (pwm *PWM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	ch.Set(ch.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*PWM) SetInverting
+
+```go
+func (pwm *PWM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*PWM) SetPeriod
+
+```go
+func (pwm *PWM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*PWM) Top
+
+```go
+func (pwm *PWM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*nrf.SPIM_Type
+	buf	*[1]byte	// 1-byte buffer for the Transfer method
+}
+```
+
+SPI on the NRF.
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to set up the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous
+write/read interface, there must always be the same number of bytes written
+as bytes read. Therefore, if the number of bytes don't match it will be
+padded until they fit: if len(w) > len(r) the extra bytes received will be
+dropped and if len(w) < len(r) extra 0 bytes will be sent.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer *RingBuffer
+}
+```
+
+UART on the NRF.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/particle-xenon.md b/content/docs/reference/microcontrollers/machine/particle-xenon.md
new file mode 100644
index 00000000..6e88ad92
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/particle-xenon.md
@@ -0,0 +1,1553 @@
+
+---
+title: particle-xenon
+---
+
+
+## Constants
+
+```go
+const (
+	P0_00	Pin	= 0
+	P0_01	Pin	= 1
+	P0_02	Pin	= 2
+	P0_03	Pin	= 3
+	P0_04	Pin	= 4
+	P0_05	Pin	= 5
+	P0_06	Pin	= 6
+	P0_07	Pin	= 7
+	P0_08	Pin	= 8
+	P0_09	Pin	= 9
+	P0_10	Pin	= 10
+	P0_11	Pin	= 11
+	P0_12	Pin	= 12
+	P0_13	Pin	= 13
+	P0_14	Pin	= 14
+	P0_15	Pin	= 15
+	P0_16	Pin	= 16
+	P0_17	Pin	= 17
+	P0_18	Pin	= 18
+	P0_19	Pin	= 19
+	P0_20	Pin	= 20
+	P0_21	Pin	= 21
+	P0_22	Pin	= 22
+	P0_23	Pin	= 23
+	P0_24	Pin	= 24
+	P0_25	Pin	= 25
+	P0_26	Pin	= 26
+	P0_27	Pin	= 27
+	P0_28	Pin	= 28
+	P0_29	Pin	= 29
+	P0_30	Pin	= 30
+	P0_31	Pin	= 31
+	P1_00	Pin	= 32
+	P1_01	Pin	= 33
+	P1_02	Pin	= 34
+	P1_03	Pin	= 35
+	P1_04	Pin	= 36
+	P1_05	Pin	= 37
+	P1_06	Pin	= 38
+	P1_07	Pin	= 39
+	P1_08	Pin	= 40
+	P1_09	Pin	= 41
+	P1_10	Pin	= 42
+	P1_11	Pin	= 43
+	P1_12	Pin	= 44
+	P1_13	Pin	= 45
+	P1_14	Pin	= 46
+	P1_15	Pin	= 47
+)
+```
+
+Hardware pins
+
+
+```go
+const HasLowFrequencyCrystal = true
+```
+
+
+
+```go
+const (
+	A0	Pin	= 3
+	A1	Pin	= 4
+	A2	Pin	= 28
+	A3	Pin	= 29
+	A4	Pin	= 30
+	A5	Pin	= 31
+	D0	Pin	= 26	// Also SDA
+	D1	Pin	= 27	// Also SCL
+	D2	Pin	= 33
+	D3	Pin	= 34
+	D4	Pin	= 40
+	D5	Pin	= 42
+	D6	Pin	= 43
+	D7	Pin	= 44	// Also LED
+	D8	Pin	= 35
+	D9	Pin	= 6	// Also TX
+	D10	Pin	= 8	// Also RX
+	D11	Pin	= 46	// Also SDI
+	D12	Pin	= 45	// Also SDO
+	D13	Pin	= 47	// Also SCK
+)
+```
+
+GPIOs
+
+
+```go
+const (
+	LED		Pin	= 44
+	LED_GREEN	Pin	= 14
+	LED_RED		Pin	= 13
+	LED_BLUE	Pin	= 15
+)
+```
+
+LEDs
+
+
+```go
+const (
+	UART_TX_PIN	Pin	= 6
+	UART_RX_PIN	Pin	= 8
+)
+```
+
+
+
+```go
+const (
+	SDA_PIN	Pin	= 26
+	SCL_PIN	Pin	= 27
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	Pin	= 47
+	SPI0_SDO_PIN	Pin	= 45
+	SPI0_SDI_PIN	Pin	= 46
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	SPI1_SCK_PIN	Pin	= 19
+	SPI1_SDO_PIN	Pin	= 20
+	SPI1_SDI_PIN	Pin	= 21
+	SPI1_CS_PIN	Pin	= 17
+	SPI1_WP_PIN	Pin	= 22
+	SPI1_HOLD_PIN	Pin	= 23
+)
+```
+
+Internal 4MB SPI Flash
+
+
+```go
+const (
+	MODE_BUTTON_PIN		Pin	= 11
+	CHARGE_STATUS_PIN	Pin	= 41
+	LIPO_VOLTAGE_PIN	Pin	= 5
+	PCB_ANTENNA_PIN		Pin	= 24
+	EXTERNAL_UFL_PIN	Pin	= 25
+	NFC1_PIN		Pin	= 9
+	NFC2_PIN		Pin	= 10
+)
+```
+
+Other peripherals
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
+	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
+	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 36h)
+	WatchdogMaxTimeout = (0xffffffff * 1000) / 32768
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	DefaultUART = UART0
+)
+```
+
+UART
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	// UART0 is the hardware UART on the NRF SoC.
+	_UART0	= UART{Buffer: NewRingBuffer()}
+	UART0	= &_UART0
+)
+```
+
+UART
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	PWM0	= &PWM{PWM: nrf.PWM0}
+	PWM1	= &PWM{PWM: nrf.PWM1}
+	PWM2	= &PWM{PWM: nrf.PWM2}
+	PWM3	= &PWM{PWM: nrf.PWM3}
+)
+```
+
+PWM
+
+
+```go
+var (
+	I2C0	= &I2C{Bus: nrf.TWIM0, BusT: nrf.TWIS0}
+	I2C1	= &I2C{Bus: nrf.TWIM1, BusT: nrf.TWIS1}
+)
+```
+
+There are 2 I2C interfaces on the NRF.
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	SPI0	= &SPI{Bus: nrf.SPIM0, buf: new([1]byte)}
+	SPI1	= &SPI{Bus: nrf.SPIM1, buf: new([1]byte)}
+	SPI2	= &SPI{Bus: nrf.SPIM2, buf: new([1]byte)}
+)
+```
+
+There are 3 SPI interfaces on the NRF528xx.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader resets the chip into the serial bootloader.
+
+
+### func EnterOTABootloader
+
+```go
+func EnterOTABootloader()
+```
+
+EnterOTABootloader resets the chip into the bootloader so that it can be
+flashed via an OTA update
+
+
+### func EnterSerialBootloader
+
+```go
+func EnterSerialBootloader()
+```
+
+EnterSerialBootloader resets the chip into the serial bootloader. After
+reset, it can be flashed using serial/nrfutil.
+
+
+### func EnterUF2Bootloader
+
+```go
+func EnterUF2Bootloader()
+```
+
+EnterUF2Bootloader resets the chip into the UF2 bootloader. After reset, it
+can be flashed via nrfutil or by copying a UF2 file to the mass storage device
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (ret uint32, err error)
+```
+
+GetRNG returns 32 bits of non-deterministic random data based on internal thermal noise.
+According to Nordic's documentation, the random output is suitable for cryptographic purposes.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() int32
+```
+
+ReadTemperature reads the silicon die temperature of the chip. The return
+value is in milli-celsius.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USBHID (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (*ADC) Configure
+
+```go
+func (a *ADC) Configure(config ADCConfig)
+```
+
+Configure configures an ADC pin to be able to read analog data.
+Reference voltage can be 150, 300, 600, 1200, 1800, 2400, 3000(default), 3600 mV
+Resolution can be 8, 10, 12(default), 14 bits
+SampleTime will be ceiled to 3(default), 5, 10, 15, 20 or 40(max) µS respectively
+Samples can be 1(default), 2, 4, 8, 16, 32, 64, 128, 256 samples
+
+
+### func (*ADC) Get
+
+```go
+func (a *ADC) Get() uint16
+```
+
+Get returns the current value of an ADC pin in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*nrf.TWIM_Type	// Called Bus to align with Bus field in nrf51
+	BusT	*nrf.TWIS_Type
+	mode	I2CMode
+}
+```
+
+I2C on the NRF528xx.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint8) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+Reply supplies the response data the controller.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) (err error)
+```
+
+Tx does a single I2C transaction at the specified address (when in controller mode).
+
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+WaitForEvent blocks the current go-routine until an I2C event is received (when in Target mode).
+
+The passed buffer will be populated for receive events, with the number of bytes
+received returned in count.  For other event types, buf is not modified and a count
+of zero is returned.
+
+For request events, the caller MUST call `Reply` to avoid hanging the i2c bus indefinitely.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDM
+
+```go
+type PDM struct {
+	device		*nrf.PDM_Type
+	defaultBuffer	int16
+}
+```
+
+PDM represents a PDM device
+
+
+
+### func (*PDM) Configure
+
+```go
+func (pdm *PDM) Configure(config PDMConfig) error
+```
+
+Configure is intended to set up the PDM interface prior to use.
+
+
+### func (*PDM) Read
+
+```go
+func (pdm *PDM) Read(buf []int16) (uint32, error)
+```
+
+Read stores a set of samples in the given target buffer.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWM
+
+```go
+type PWM struct {
+	PWM	*nrf.PWM_Type
+
+	channelValues	[4]volatile.Register16
+}
+```
+
+PWM is one PWM peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this PWM peripheral at
+once.
+
+
+
+### func (*PWM) Channel
+
+```go
+func (pwm *PWM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*PWM) Configure
+
+```go
+func (pwm *PWM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+On the nRF52 series, the maximum period is around 0.26s.
+
+
+### func (*PWM) Set
+
+```go
+func (pwm *PWM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	ch.Set(ch.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*PWM) SetInverting
+
+```go
+func (pwm *PWM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*PWM) SetPeriod
+
+```go
+func (pwm *PWM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*PWM) Top
+
+```go
+func (pwm *PWM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*nrf.SPIM_Type
+	buf	*[1]byte	// 1-byte buffer for the Transfer method
+}
+```
+
+SPI on the NRF.
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to set up the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous
+write/read interface, there must always be the same number of bytes written
+as bytes read. Therefore, if the number of bytes don't match it will be
+padded until they fit: if len(w) > len(r) the extra bytes received will be
+dropped and if len(w) < len(r) extra 0 bytes will be sent.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer *RingBuffer
+}
+```
+
+UART on the NRF.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/pca10031.md b/content/docs/reference/microcontrollers/machine/pca10031.md
new file mode 100644
index 00000000..630a04f4
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/pca10031.md
@@ -0,0 +1,1111 @@
+
+---
+title: pca10031
+---
+
+
+## Constants
+
+```go
+const (
+	P0_00	Pin	= 0
+	P0_01	Pin	= 1
+	P0_02	Pin	= 2
+	P0_03	Pin	= 3
+	P0_04	Pin	= 4
+	P0_05	Pin	= 5
+	P0_06	Pin	= 6
+	P0_07	Pin	= 7
+	P0_08	Pin	= 8
+	P0_09	Pin	= 9
+	P0_10	Pin	= 10
+	P0_11	Pin	= 11
+	P0_12	Pin	= 12
+	P0_13	Pin	= 13
+	P0_14	Pin	= 14
+	P0_15	Pin	= 15
+	P0_16	Pin	= 16
+	P0_17	Pin	= 17
+	P0_18	Pin	= 18
+	P0_19	Pin	= 19
+	P0_20	Pin	= 20
+	P0_21	Pin	= 21
+	P0_22	Pin	= 22
+	P0_23	Pin	= 23
+	P0_24	Pin	= 24
+	P0_25	Pin	= 25
+	P0_26	Pin	= 26
+	P0_27	Pin	= 27
+	P0_28	Pin	= 28
+	P0_29	Pin	= 29
+	P0_30	Pin	= 30
+	P0_31	Pin	= 31
+)
+```
+
+Hardware pins
+
+
+```go
+const HasLowFrequencyCrystal = true
+```
+
+The pca10031 has a 32kHz crystal on board.
+
+
+```go
+const (
+	LED1		= LED_RED
+	LED2		= LED_GREEN
+	LED3		= LED_BLUE
+	LED_RED		= P0_21
+	LED_GREEN	= P0_22
+	LED_BLUE	= P0_23
+	LED		= LED_RED
+)
+```
+
+LED on the pca10031
+
+
+```go
+const (
+	UART_TX_PIN	= P0_09
+	UART_RX_PIN	= P0_11
+)
+```
+
+UART pins
+
+
+```go
+const (
+	SDA_PIN	= NoPin
+	SCL_PIN	= NoPin
+)
+```
+
+I2C pins (disabled)
+
+
+```go
+const (
+	SPI0_SCK_PIN	= NoPin
+	SPI0_SDO_PIN	= NoPin
+	SPI0_SDI_PIN	= NoPin
+)
+```
+
+SPI pins (unused)
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
+	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
+	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	// UART0 is the hardware UART on the NRF SoC.
+	_UART0	= UART{Buffer: NewRingBuffer()}
+	UART0	= &_UART0
+)
+```
+
+UART
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	SPI0	= &SPI{Bus: nrf.SPI0}
+	SPI1	= &SPI{Bus: nrf.SPI1}
+)
+```
+
+There are 2 SPI interfaces on the NRF51.
+
+
+```go
+var (
+	I2C0	= &I2C{Bus: nrf.TWI0}
+	I2C1	= &I2C{Bus: nrf.TWI1}
+)
+```
+
+There are 2 I2C interfaces on the NRF.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (ret uint32, err error)
+```
+
+GetRNG returns 32 bits of non-deterministic random data based on internal thermal noise.
+According to Nordic's documentation, the random output is suitable for cryptographic purposes.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() int32
+```
+
+ReadTemperature reads the silicon die temperature of the chip. The return
+value is in milli-celsius.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(ADCConfig)
+```
+
+Configure configures an ADC pin to be able to read analog data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*nrf.TWI_Type
+	mode	I2CMode
+}
+```
+
+I2C on the NRF51 and NRF52.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) (err error)
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus *nrf.SPI_Type
+}
+```
+
+SPI on the NRF.
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer *RingBuffer
+}
+```
+
+UART on the NRF.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/pca10040.md b/content/docs/reference/microcontrollers/machine/pca10040.md
new file mode 100644
index 00000000..f1cc383c
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/pca10040.md
@@ -0,0 +1,1245 @@
+
+---
+title: pca10040
+---
+
+
+## Constants
+
+```go
+const HasLowFrequencyCrystal = true
+```
+
+The PCA10040 has a low-frequency (32kHz) crystal oscillator on board.
+
+
+```go
+const (
+	LED1	Pin	= 17
+	LED2	Pin	= 18
+	LED3	Pin	= 19
+	LED4	Pin	= 20
+	LED	Pin	= LED1
+)
+```
+
+LEDs on the PCA10040 (nRF52832 dev board)
+
+
+```go
+const (
+	BUTTON1	Pin	= 13
+	BUTTON2	Pin	= 14
+	BUTTON3	Pin	= 15
+	BUTTON4	Pin	= 16
+	BUTTON	Pin	= BUTTON1
+)
+```
+
+Buttons on the PCA10040 (nRF52832 dev board)
+
+
+```go
+const (
+	UART_TX_PIN	Pin	= 6
+	UART_RX_PIN	Pin	= 8
+)
+```
+
+UART pins for NRF52840-DK
+
+
+```go
+const (
+	ADC0	Pin	= 3
+	ADC1	Pin	= 4
+	ADC2	Pin	= 28
+	ADC3	Pin	= 29
+	ADC4	Pin	= 30
+	ADC5	Pin	= 31
+)
+```
+
+ADC pins
+
+
+```go
+const (
+	SDA_PIN	Pin	= 26
+	SCL_PIN	Pin	= 27
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	Pin	= 25
+	SPI0_SDO_PIN	Pin	= 23
+	SPI0_SDI_PIN	Pin	= 24
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
+	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
+	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	P0_00	Pin	= 0
+	P0_01	Pin	= 1
+	P0_02	Pin	= 2
+	P0_03	Pin	= 3
+	P0_04	Pin	= 4
+	P0_05	Pin	= 5
+	P0_06	Pin	= 6
+	P0_07	Pin	= 7
+	P0_08	Pin	= 8
+	P0_09	Pin	= 9
+	P0_10	Pin	= 10
+	P0_11	Pin	= 11
+	P0_12	Pin	= 12
+	P0_13	Pin	= 13
+	P0_14	Pin	= 14
+	P0_15	Pin	= 15
+	P0_16	Pin	= 16
+	P0_17	Pin	= 17
+	P0_18	Pin	= 18
+	P0_19	Pin	= 19
+	P0_20	Pin	= 20
+	P0_21	Pin	= 21
+	P0_22	Pin	= 22
+	P0_23	Pin	= 23
+	P0_24	Pin	= 24
+	P0_25	Pin	= 25
+	P0_26	Pin	= 26
+	P0_27	Pin	= 27
+	P0_28	Pin	= 28
+	P0_29	Pin	= 29
+	P0_30	Pin	= 30
+	P0_31	Pin	= 31
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	// UART0 is the hardware UART on the NRF SoC.
+	_UART0	= UART{Buffer: NewRingBuffer()}
+	UART0	= &_UART0
+)
+```
+
+UART
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	PWM0	= &PWM{PWM: nrf.PWM0}
+	PWM1	= &PWM{PWM: nrf.PWM1}
+	PWM2	= &PWM{PWM: nrf.PWM2}
+)
+```
+
+PWM
+
+
+```go
+var (
+	SPI0	= &SPI{Bus: nrf.SPIM0, buf: new([1]byte)}
+	SPI1	= &SPI{Bus: nrf.SPIM1, buf: new([1]byte)}
+	SPI2	= &SPI{Bus: nrf.SPIM2, buf: new([1]byte)}
+)
+```
+
+There are 3 SPI interfaces on the NRF528xx.
+
+
+```go
+var (
+	I2C0	= &I2C{Bus: nrf.TWI0}
+	I2C1	= &I2C{Bus: nrf.TWI1}
+)
+```
+
+There are 2 I2C interfaces on the NRF.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (ret uint32, err error)
+```
+
+GetRNG returns 32 bits of non-deterministic random data based on internal thermal noise.
+According to Nordic's documentation, the random output is suitable for cryptographic purposes.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() int32
+```
+
+ReadTemperature reads the silicon die temperature of the chip. The return
+value is in milli-celsius.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (*ADC) Configure
+
+```go
+func (a *ADC) Configure(config ADCConfig)
+```
+
+Configure configures an ADC pin to be able to read analog data.
+Reference voltage can be 150, 300, 600, 1200, 1800, 2400, 3000(default), 3600 mV
+Resolution can be 8, 10, 12(default), 14 bits
+SampleTime will be ceiled to 3(default), 5, 10, 15, 20 or 40(max) µS respectively
+Samples can be 1(default), 2, 4, 8, 16, 32, 64, 128, 256 samples
+
+
+### func (*ADC) Get
+
+```go
+func (a *ADC) Get() uint16
+```
+
+Get returns the current value of an ADC pin in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*nrf.TWI_Type
+	mode	I2CMode
+}
+```
+
+I2C on the NRF51 and NRF52.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) (err error)
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWM
+
+```go
+type PWM struct {
+	PWM	*nrf.PWM_Type
+
+	channelValues	[4]volatile.Register16
+}
+```
+
+PWM is one PWM peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this PWM peripheral at
+once.
+
+
+
+### func (*PWM) Channel
+
+```go
+func (pwm *PWM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*PWM) Configure
+
+```go
+func (pwm *PWM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+On the nRF52 series, the maximum period is around 0.26s.
+
+
+### func (*PWM) Set
+
+```go
+func (pwm *PWM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	ch.Set(ch.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*PWM) SetInverting
+
+```go
+func (pwm *PWM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*PWM) SetPeriod
+
+```go
+func (pwm *PWM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*PWM) Top
+
+```go
+func (pwm *PWM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*nrf.SPIM_Type
+	buf	*[1]byte	// 1-byte buffer for the Transfer method
+}
+```
+
+SPI on the NRF.
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to set up the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous
+write/read interface, there must always be the same number of bytes written
+as bytes read. Therefore, if the number of bytes don't match it will be
+padded until they fit: if len(w) > len(r) the extra bytes received will be
+dropped and if len(w) < len(r) extra 0 bytes will be sent.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer *RingBuffer
+}
+```
+
+UART on the NRF.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/pca10056.md b/content/docs/reference/microcontrollers/machine/pca10056.md
new file mode 100644
index 00000000..82b95e3b
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/pca10056.md
@@ -0,0 +1,1522 @@
+
+---
+title: pca10056
+---
+
+
+## Constants
+
+```go
+const (
+	P0_00	Pin	= 0
+	P0_01	Pin	= 1
+	P0_02	Pin	= 2
+	P0_03	Pin	= 3
+	P0_04	Pin	= 4
+	P0_05	Pin	= 5
+	P0_06	Pin	= 6
+	P0_07	Pin	= 7
+	P0_08	Pin	= 8
+	P0_09	Pin	= 9
+	P0_10	Pin	= 10
+	P0_11	Pin	= 11
+	P0_12	Pin	= 12
+	P0_13	Pin	= 13
+	P0_14	Pin	= 14
+	P0_15	Pin	= 15
+	P0_16	Pin	= 16
+	P0_17	Pin	= 17
+	P0_18	Pin	= 18
+	P0_19	Pin	= 19
+	P0_20	Pin	= 20
+	P0_21	Pin	= 21
+	P0_22	Pin	= 22
+	P0_23	Pin	= 23
+	P0_24	Pin	= 24
+	P0_25	Pin	= 25
+	P0_26	Pin	= 26
+	P0_27	Pin	= 27
+	P0_28	Pin	= 28
+	P0_29	Pin	= 29
+	P0_30	Pin	= 30
+	P0_31	Pin	= 31
+	P1_00	Pin	= 32
+	P1_01	Pin	= 33
+	P1_02	Pin	= 34
+	P1_03	Pin	= 35
+	P1_04	Pin	= 36
+	P1_05	Pin	= 37
+	P1_06	Pin	= 38
+	P1_07	Pin	= 39
+	P1_08	Pin	= 40
+	P1_09	Pin	= 41
+	P1_10	Pin	= 42
+	P1_11	Pin	= 43
+	P1_12	Pin	= 44
+	P1_13	Pin	= 45
+	P1_14	Pin	= 46
+	P1_15	Pin	= 47
+)
+```
+
+Hardware pins
+
+
+```go
+const HasLowFrequencyCrystal = true
+```
+
+
+
+```go
+const (
+	LED1	Pin	= 13
+	LED2	Pin	= 14
+	LED3	Pin	= 15
+	LED4	Pin	= 16
+	LED	Pin	= LED1
+)
+```
+
+LEDs on the pca10056
+
+
+```go
+const (
+	BUTTON1	Pin	= 11
+	BUTTON2	Pin	= 12
+	BUTTON3	Pin	= 24
+	BUTTON4	Pin	= 25
+	BUTTON	Pin	= BUTTON1
+)
+```
+
+Buttons on the pca10056
+
+
+```go
+const (
+	UART_TX_PIN	Pin	= 6
+	UART_RX_PIN	Pin	= 8
+)
+```
+
+UART pins
+
+
+```go
+const (
+	ADC0	Pin	= 3
+	ADC1	Pin	= 4
+	ADC2	Pin	= 28
+	ADC3	Pin	= 29
+	ADC4	Pin	= 30
+	ADC5	Pin	= 31
+)
+```
+
+ADC pins
+
+
+```go
+const (
+	SDA_PIN	Pin	= 26	// P0.26
+	SCL_PIN	Pin	= 27	// P0.27
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	Pin	= 47	// P1.15
+	SPI0_SDO_PIN	Pin	= 45	// P1.13
+	SPI0_SDI_PIN	Pin	= 46	// P1.14
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
+	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
+	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 36h)
+	WatchdogMaxTimeout = (0xffffffff * 1000) / 32768
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	// UART0 is the hardware UART on the NRF SoC.
+	_UART0	= UART{Buffer: NewRingBuffer()}
+	UART0	= &_UART0
+)
+```
+
+UART
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	PWM0	= &PWM{PWM: nrf.PWM0}
+	PWM1	= &PWM{PWM: nrf.PWM1}
+	PWM2	= &PWM{PWM: nrf.PWM2}
+	PWM3	= &PWM{PWM: nrf.PWM3}
+)
+```
+
+PWM
+
+
+```go
+var (
+	I2C0	= &I2C{Bus: nrf.TWIM0, BusT: nrf.TWIS0}
+	I2C1	= &I2C{Bus: nrf.TWIM1, BusT: nrf.TWIS1}
+)
+```
+
+There are 2 I2C interfaces on the NRF.
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	SPI0	= &SPI{Bus: nrf.SPIM0, buf: new([1]byte)}
+	SPI1	= &SPI{Bus: nrf.SPIM1, buf: new([1]byte)}
+	SPI2	= &SPI{Bus: nrf.SPIM2, buf: new([1]byte)}
+)
+```
+
+There are 3 SPI interfaces on the NRF528xx.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader resets the chip into the serial bootloader.
+
+
+### func EnterOTABootloader
+
+```go
+func EnterOTABootloader()
+```
+
+EnterOTABootloader resets the chip into the bootloader so that it can be
+flashed via an OTA update
+
+
+### func EnterSerialBootloader
+
+```go
+func EnterSerialBootloader()
+```
+
+EnterSerialBootloader resets the chip into the serial bootloader. After
+reset, it can be flashed using serial/nrfutil.
+
+
+### func EnterUF2Bootloader
+
+```go
+func EnterUF2Bootloader()
+```
+
+EnterUF2Bootloader resets the chip into the UF2 bootloader. After reset, it
+can be flashed via nrfutil or by copying a UF2 file to the mass storage device
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (ret uint32, err error)
+```
+
+GetRNG returns 32 bits of non-deterministic random data based on internal thermal noise.
+According to Nordic's documentation, the random output is suitable for cryptographic purposes.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() int32
+```
+
+ReadTemperature reads the silicon die temperature of the chip. The return
+value is in milli-celsius.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USBHID (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (*ADC) Configure
+
+```go
+func (a *ADC) Configure(config ADCConfig)
+```
+
+Configure configures an ADC pin to be able to read analog data.
+Reference voltage can be 150, 300, 600, 1200, 1800, 2400, 3000(default), 3600 mV
+Resolution can be 8, 10, 12(default), 14 bits
+SampleTime will be ceiled to 3(default), 5, 10, 15, 20 or 40(max) µS respectively
+Samples can be 1(default), 2, 4, 8, 16, 32, 64, 128, 256 samples
+
+
+### func (*ADC) Get
+
+```go
+func (a *ADC) Get() uint16
+```
+
+Get returns the current value of an ADC pin in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*nrf.TWIM_Type	// Called Bus to align with Bus field in nrf51
+	BusT	*nrf.TWIS_Type
+	mode	I2CMode
+}
+```
+
+I2C on the NRF528xx.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint8) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+Reply supplies the response data the controller.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) (err error)
+```
+
+Tx does a single I2C transaction at the specified address (when in controller mode).
+
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+WaitForEvent blocks the current go-routine until an I2C event is received (when in Target mode).
+
+The passed buffer will be populated for receive events, with the number of bytes
+received returned in count.  For other event types, buf is not modified and a count
+of zero is returned.
+
+For request events, the caller MUST call `Reply` to avoid hanging the i2c bus indefinitely.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDM
+
+```go
+type PDM struct {
+	device		*nrf.PDM_Type
+	defaultBuffer	int16
+}
+```
+
+PDM represents a PDM device
+
+
+
+### func (*PDM) Configure
+
+```go
+func (pdm *PDM) Configure(config PDMConfig) error
+```
+
+Configure is intended to set up the PDM interface prior to use.
+
+
+### func (*PDM) Read
+
+```go
+func (pdm *PDM) Read(buf []int16) (uint32, error)
+```
+
+Read stores a set of samples in the given target buffer.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWM
+
+```go
+type PWM struct {
+	PWM	*nrf.PWM_Type
+
+	channelValues	[4]volatile.Register16
+}
+```
+
+PWM is one PWM peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this PWM peripheral at
+once.
+
+
+
+### func (*PWM) Channel
+
+```go
+func (pwm *PWM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*PWM) Configure
+
+```go
+func (pwm *PWM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+On the nRF52 series, the maximum period is around 0.26s.
+
+
+### func (*PWM) Set
+
+```go
+func (pwm *PWM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	ch.Set(ch.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*PWM) SetInverting
+
+```go
+func (pwm *PWM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*PWM) SetPeriod
+
+```go
+func (pwm *PWM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*PWM) Top
+
+```go
+func (pwm *PWM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*nrf.SPIM_Type
+	buf	*[1]byte	// 1-byte buffer for the Transfer method
+}
+```
+
+SPI on the NRF.
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to set up the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous
+write/read interface, there must always be the same number of bytes written
+as bytes read. Therefore, if the number of bytes don't match it will be
+padded until they fit: if len(w) > len(r) the extra bytes received will be
+dropped and if len(w) < len(r) extra 0 bytes will be sent.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer *RingBuffer
+}
+```
+
+UART on the NRF.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/pca10059.md b/content/docs/reference/microcontrollers/machine/pca10059.md
new file mode 100644
index 00000000..82814983
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/pca10059.md
@@ -0,0 +1,1512 @@
+
+---
+title: pca10059
+---
+
+
+## Constants
+
+```go
+const (
+	P0_00	Pin	= 0
+	P0_01	Pin	= 1
+	P0_02	Pin	= 2
+	P0_03	Pin	= 3
+	P0_04	Pin	= 4
+	P0_05	Pin	= 5
+	P0_06	Pin	= 6
+	P0_07	Pin	= 7
+	P0_08	Pin	= 8
+	P0_09	Pin	= 9
+	P0_10	Pin	= 10
+	P0_11	Pin	= 11
+	P0_12	Pin	= 12
+	P0_13	Pin	= 13
+	P0_14	Pin	= 14
+	P0_15	Pin	= 15
+	P0_16	Pin	= 16
+	P0_17	Pin	= 17
+	P0_18	Pin	= 18
+	P0_19	Pin	= 19
+	P0_20	Pin	= 20
+	P0_21	Pin	= 21
+	P0_22	Pin	= 22
+	P0_23	Pin	= 23
+	P0_24	Pin	= 24
+	P0_25	Pin	= 25
+	P0_26	Pin	= 26
+	P0_27	Pin	= 27
+	P0_28	Pin	= 28
+	P0_29	Pin	= 29
+	P0_30	Pin	= 30
+	P0_31	Pin	= 31
+	P1_00	Pin	= 32
+	P1_01	Pin	= 33
+	P1_02	Pin	= 34
+	P1_03	Pin	= 35
+	P1_04	Pin	= 36
+	P1_05	Pin	= 37
+	P1_06	Pin	= 38
+	P1_07	Pin	= 39
+	P1_08	Pin	= 40
+	P1_09	Pin	= 41
+	P1_10	Pin	= 42
+	P1_11	Pin	= 43
+	P1_12	Pin	= 44
+	P1_13	Pin	= 45
+	P1_14	Pin	= 46
+	P1_15	Pin	= 47
+)
+```
+
+Hardware pins
+
+
+```go
+const HasLowFrequencyCrystal = true
+```
+
+The PCA10040 has a low-frequency (32kHz) crystal oscillator on board.
+
+
+```go
+const (
+	LED1	Pin	= 6
+	LED2	Pin	= 8
+	LED3	Pin	= (1 << 5) | 9
+	LED4	Pin	= 12
+	LED	Pin	= LED1
+)
+```
+
+LEDs on the PCA10059 (nRF52840 dongle)
+
+
+```go
+const (
+	BUTTON1	Pin	= (1 << 5) | 6
+	BUTTON	Pin	= BUTTON1
+)
+```
+
+Buttons on the PCA10059 (nRF52840 dongle)
+
+
+```go
+const (
+	ADC1	Pin	= 2
+	ADC2	Pin	= 4
+	ADC3	Pin	= 29
+	ADC4	Pin	= 31
+)
+```
+
+ADC pins
+
+
+```go
+const (
+	UART_TX_PIN	Pin	= NoPin
+	UART_RX_PIN	Pin	= NoPin
+)
+```
+
+UART pins
+
+
+```go
+const (
+	SDA_PIN	= NoPin
+	SCL_PIN	= NoPin
+)
+```
+
+I2C pins (unused)
+
+
+```go
+const (
+	SPI0_SCK_PIN	= NoPin
+	SPI0_SDO_PIN	= NoPin
+	SPI0_SDI_PIN	= NoPin
+)
+```
+
+SPI pins (unused)
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
+	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
+	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 36h)
+	WatchdogMaxTimeout = (0xffffffff * 1000) / 32768
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	// UART0 is the hardware UART on the NRF SoC.
+	_UART0	= UART{Buffer: NewRingBuffer()}
+	UART0	= &_UART0
+)
+```
+
+UART
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	PWM0	= &PWM{PWM: nrf.PWM0}
+	PWM1	= &PWM{PWM: nrf.PWM1}
+	PWM2	= &PWM{PWM: nrf.PWM2}
+	PWM3	= &PWM{PWM: nrf.PWM3}
+)
+```
+
+PWM
+
+
+```go
+var (
+	I2C0	= &I2C{Bus: nrf.TWIM0, BusT: nrf.TWIS0}
+	I2C1	= &I2C{Bus: nrf.TWIM1, BusT: nrf.TWIS1}
+)
+```
+
+There are 2 I2C interfaces on the NRF.
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	SPI0	= &SPI{Bus: nrf.SPIM0, buf: new([1]byte)}
+	SPI1	= &SPI{Bus: nrf.SPIM1, buf: new([1]byte)}
+	SPI2	= &SPI{Bus: nrf.SPIM2, buf: new([1]byte)}
+)
+```
+
+There are 3 SPI interfaces on the NRF528xx.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader resets the chip into the serial bootloader.
+
+
+### func EnterOTABootloader
+
+```go
+func EnterOTABootloader()
+```
+
+EnterOTABootloader resets the chip into the bootloader so that it can be
+flashed via an OTA update
+
+
+### func EnterSerialBootloader
+
+```go
+func EnterSerialBootloader()
+```
+
+EnterSerialBootloader resets the chip into the serial bootloader. After
+reset, it can be flashed using serial/nrfutil.
+
+
+### func EnterUF2Bootloader
+
+```go
+func EnterUF2Bootloader()
+```
+
+EnterUF2Bootloader resets the chip into the UF2 bootloader. After reset, it
+can be flashed via nrfutil or by copying a UF2 file to the mass storage device
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (ret uint32, err error)
+```
+
+GetRNG returns 32 bits of non-deterministic random data based on internal thermal noise.
+According to Nordic's documentation, the random output is suitable for cryptographic purposes.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() int32
+```
+
+ReadTemperature reads the silicon die temperature of the chip. The return
+value is in milli-celsius.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USBHID (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (*ADC) Configure
+
+```go
+func (a *ADC) Configure(config ADCConfig)
+```
+
+Configure configures an ADC pin to be able to read analog data.
+Reference voltage can be 150, 300, 600, 1200, 1800, 2400, 3000(default), 3600 mV
+Resolution can be 8, 10, 12(default), 14 bits
+SampleTime will be ceiled to 3(default), 5, 10, 15, 20 or 40(max) µS respectively
+Samples can be 1(default), 2, 4, 8, 16, 32, 64, 128, 256 samples
+
+
+### func (*ADC) Get
+
+```go
+func (a *ADC) Get() uint16
+```
+
+Get returns the current value of an ADC pin in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*nrf.TWIM_Type	// Called Bus to align with Bus field in nrf51
+	BusT	*nrf.TWIS_Type
+	mode	I2CMode
+}
+```
+
+I2C on the NRF528xx.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint8) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+Reply supplies the response data the controller.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) (err error)
+```
+
+Tx does a single I2C transaction at the specified address (when in controller mode).
+
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+WaitForEvent blocks the current go-routine until an I2C event is received (when in Target mode).
+
+The passed buffer will be populated for receive events, with the number of bytes
+received returned in count.  For other event types, buf is not modified and a count
+of zero is returned.
+
+For request events, the caller MUST call `Reply` to avoid hanging the i2c bus indefinitely.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDM
+
+```go
+type PDM struct {
+	device		*nrf.PDM_Type
+	defaultBuffer	int16
+}
+```
+
+PDM represents a PDM device
+
+
+
+### func (*PDM) Configure
+
+```go
+func (pdm *PDM) Configure(config PDMConfig) error
+```
+
+Configure is intended to set up the PDM interface prior to use.
+
+
+### func (*PDM) Read
+
+```go
+func (pdm *PDM) Read(buf []int16) (uint32, error)
+```
+
+Read stores a set of samples in the given target buffer.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWM
+
+```go
+type PWM struct {
+	PWM	*nrf.PWM_Type
+
+	channelValues	[4]volatile.Register16
+}
+```
+
+PWM is one PWM peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this PWM peripheral at
+once.
+
+
+
+### func (*PWM) Channel
+
+```go
+func (pwm *PWM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*PWM) Configure
+
+```go
+func (pwm *PWM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+On the nRF52 series, the maximum period is around 0.26s.
+
+
+### func (*PWM) Set
+
+```go
+func (pwm *PWM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	ch.Set(ch.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*PWM) SetInverting
+
+```go
+func (pwm *PWM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*PWM) SetPeriod
+
+```go
+func (pwm *PWM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*PWM) Top
+
+```go
+func (pwm *PWM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*nrf.SPIM_Type
+	buf	*[1]byte	// 1-byte buffer for the Transfer method
+}
+```
+
+SPI on the NRF.
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to set up the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous
+write/read interface, there must always be the same number of bytes written
+as bytes read. Therefore, if the number of bytes don't match it will be
+padded until they fit: if len(w) > len(r) the extra bytes received will be
+dropped and if len(w) < len(r) extra 0 bytes will be sent.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer *RingBuffer
+}
+```
+
+UART on the NRF.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/pico-w.md b/content/docs/reference/microcontrollers/machine/pico-w.md
new file mode 100644
index 00000000..5ea63392
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/pico-w.md
@@ -0,0 +1,1689 @@
+
+---
+title: pico-w
+---
+
+
+## Constants
+
+```go
+const (
+	GP0	Pin	= GPIO0
+	GP1	Pin	= GPIO1
+	GP2	Pin	= GPIO2
+	GP3	Pin	= GPIO3
+	GP4	Pin	= GPIO4
+	GP5	Pin	= GPIO5
+	GP6	Pin	= GPIO6
+	GP7	Pin	= GPIO7
+	GP8	Pin	= GPIO8
+	GP9	Pin	= GPIO9
+	GP10	Pin	= GPIO10
+	GP11	Pin	= GPIO11
+	GP12	Pin	= GPIO12
+	GP13	Pin	= GPIO13
+	GP14	Pin	= GPIO14
+	GP15	Pin	= GPIO15
+	GP16	Pin	= GPIO16
+	GP17	Pin	= GPIO17
+	GP18	Pin	= GPIO18
+	GP19	Pin	= GPIO19
+	GP20	Pin	= GPIO20
+	GP21	Pin	= GPIO21
+	GP22	Pin	= GPIO22
+	GP26	Pin	= GPIO26
+	GP27	Pin	= GPIO27
+	GP28	Pin	= GPIO28
+
+	// Onboard LED
+	LED	Pin	= GPIO25
+
+	// Onboard crystal oscillator frequency, in MHz.
+	xoscFreq	= 12	// MHz
+)
+```
+
+GPIO pins
+
+
+```go
+const (
+	I2C0_SDA_PIN	= GP4
+	I2C0_SCL_PIN	= GP5
+
+	I2C1_SDA_PIN	= GP2
+	I2C1_SCL_PIN	= GP3
+)
+```
+
+I2C Default pins on Raspberry Pico.
+
+
+```go
+const (
+	// Default Serial Clock Bus 0 for SPI communications
+	SPI0_SCK_PIN	= GPIO18
+	// Default Serial Out Bus 0 for SPI communications
+	SPI0_SDO_PIN	= GPIO19	// Tx
+	// Default Serial In Bus 0 for SPI communications
+	SPI0_SDI_PIN	= GPIO16	// Rx
+
+	// Default Serial Clock Bus 1 for SPI communications
+	SPI1_SCK_PIN	= GPIO10
+	// Default Serial Out Bus 1 for SPI communications
+	SPI1_SDO_PIN	= GPIO11	// Tx
+	// Default Serial In Bus 1 for SPI communications
+	SPI1_SDI_PIN	= GPIO12	// Rx
+)
+```
+
+SPI default pins
+
+
+```go
+const (
+	UART0_TX_PIN	= GPIO0
+	UART0_RX_PIN	= GPIO1
+	UART1_TX_PIN	= GPIO8
+	UART1_RX_PIN	= GPIO9
+	UART_TX_PIN	= UART0_TX_PIN
+	UART_RX_PIN	= UART0_RX_PIN
+)
+```
+
+UART pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	LS_SE0	= 0b00
+	LS_J	= 0b01
+	LS_K	= 0b10
+	LS_SE1	= 0b11
+)
+```
+
+
+
+```go
+const (
+	cpuFreq			= 200 * MHz
+	_NUMBANK0_GPIOS		= 30
+	_NUMBANK0_IRQS		= 4
+	_NUMIRQ			= 32
+	rp2350ExtraReg		= 0
+	RESETS_RESET_Msk	= 0x01ffffff
+	initUnreset		= rp.RESETS_RESET_ADC |
+		rp.RESETS_RESET_RTC |
+		rp.RESETS_RESET_SPI0 |
+		rp.RESETS_RESET_SPI1 |
+		rp.RESETS_RESET_UART0 |
+		rp.RESETS_RESET_UART1 |
+		rp.RESETS_RESET_USBCTRL
+	initDontReset	= rp.RESETS_RESET_IO_QSPI |
+		rp.RESETS_RESET_PADS_QSPI |
+		rp.RESETS_RESET_PLL_USB |
+		rp.RESETS_RESET_USBCTRL |
+		rp.RESETS_RESET_SYSCFG |
+		rp.RESETS_RESET_PLL_SYS
+	padEnableMask	= rp.PADS_BANK0_GPIO0_IE_Msk |
+		rp.PADS_BANK0_GPIO0_OD_Msk
+)
+```
+
+
+
+```go
+const (
+	PinOutput	PinMode	= iota
+	PinInput
+	PinInputPulldown
+	PinInputPullup
+	PinAnalog
+	PinUART
+	PinPWM
+	PinI2C
+	PinSPI
+	PinPIO0
+	PinPIO1
+)
+```
+
+
+
+```go
+const (
+	ADC0	Pin	= GPIO26
+	ADC1	Pin	= GPIO27
+	ADC2	Pin	= GPIO28
+	ADC3	Pin	= GPIO29
+
+	thermADC	= 30
+)
+```
+
+Analog pins on RP2040.
+
+
+```go
+const (
+	// Edge falling
+	PinFalling	PinChange	= 4 << iota
+	// Edge rising
+	PinRising
+
+	PinToggle	= PinFalling | PinRising
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// GPIO pins
+	GPIO0	Pin	= 0	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO1	Pin	= 1	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO2	Pin	= 2	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO3	Pin	= 3	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO4	Pin	= 4	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO5	Pin	= 5	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO6	Pin	= 6	// peripherals: PWM3 channel A, I2C1 SDA
+	GPIO7	Pin	= 7	// peripherals: PWM3 channel B, I2C1 SCL
+	GPIO8	Pin	= 8	// peripherals: PWM4 channel A, I2C0 SDA
+	GPIO9	Pin	= 9	// peripherals: PWM4 channel B, I2C0 SCL
+	GPIO10	Pin	= 10	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO11	Pin	= 11	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO12	Pin	= 12	// peripherals: PWM6 channel A, I2C0 SDA
+	GPIO13	Pin	= 13	// peripherals: PWM6 channel B, I2C0 SCL
+	GPIO14	Pin	= 14	// peripherals: PWM7 channel A, I2C1 SDA
+	GPIO15	Pin	= 15	// peripherals: PWM7 channel B, I2C1 SCL
+	GPIO16	Pin	= 16	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO17	Pin	= 17	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO18	Pin	= 18	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO19	Pin	= 19	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO20	Pin	= 20	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO21	Pin	= 21	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO22	Pin	= 22	// peripherals: PWM3 channel A
+	GPIO23	Pin	= 23	// peripherals: PWM3 channel B
+	GPIO24	Pin	= 24	// peripherals: PWM4 channel A
+	GPIO25	Pin	= 25	// peripherals: PWM4 channel B
+	GPIO26	Pin	= 26	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO27	Pin	= 27	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO28	Pin	= 28	// peripherals: PWM6 channel A
+	GPIO29	Pin	= 29	// peripherals: PWM6 channel B
+)
+```
+
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 8.3s).
+	//
+	// Nominal 1us per watchdog tick, 24-bit counter,
+	// but due to errata two ticks consumed per 1us.
+	// See: Errata RP2040-E1
+	WatchdogMaxTimeout = (rp.WATCHDOG_LOAD_LOAD_Msk / 1000) / 2
+)
+```
+
+
+
+```go
+const XOSC_STARTUP_DELAY_MULTIPLIER = 64
+```
+
+On some boards, the XOSC can take longer than usual to stabilize. On such
+boards, this is needed to avoid a hard fault on boot/reset. Refer to
+PICO_XOSC_STARTUP_DELAY_MULTIPLIER in the Pico SDK for additional details.
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	UART0	= &_UART0
+	_UART0	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART0,
+	}
+
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART1,
+	}
+)
+```
+
+UART on the RP2040
+
+
+```go
+var RTC = (*rtcType)(unsafe.Pointer(rp.RTC))
+```
+
+
+
+```go
+var (
+	ErrRtcDelayTooSmall	= errors.New("RTC interrupt deplay is too small, shall be at least 1 second")
+	ErrRtcDelayTooLarge	= errors.New("RTC interrupt deplay is too large, shall be no more than 1 day")
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	I2C0	= &_I2C0
+	_I2C0	= I2C{
+		Bus: rp.I2C0,
+	}
+	I2C1	= &_I2C1
+	_I2C1	= I2C{
+		Bus: rp.I2C1,
+	}
+)
+```
+
+I2C on the RP2040/RP2350
+
+
+```go
+var (
+	ErrBadPeriod = errors.New("period outside valid range 8ns..268ms")
+)
+```
+
+
+
+```go
+var (
+	PWM0	= getPWMGroup(0)
+	PWM1	= getPWMGroup(1)
+	PWM2	= getPWMGroup(2)
+	PWM3	= getPWMGroup(3)
+	PWM4	= getPWMGroup(4)
+	PWM5	= getPWMGroup(5)
+	PWM6	= getPWMGroup(6)
+	PWM7	= getPWMGroup(7)
+)
+```
+
+Hardware Pulse Width Modulation (PWM) API
+PWM peripherals available on RP2040. Each peripheral has 2 pins available for
+a total of 16 available PWM outputs. Some pins may not be available on some boards.
+
+The RP2040 PWM block has 8 identical slices. Each slice can drive two PWM output signals, or
+measure the frequency or duty cycle of an input signal. This gives a total of up to 16 controllable
+PWM outputs. All 30 GPIOs can be driven by the PWM block
+
+The PWM hardware functions by continuously comparing the input value to a free-running counter. This produces a
+toggling output where the amount of time spent at the high output level is proportional to the input value. The fraction of
+time spent at the high signal level is known as the duty cycle of the signal.
+
+The default behaviour of a PWM slice is to count upward until the wrap value (\ref pwm_config_set_wrap) is reached, and then
+immediately wrap to 0. PWM slices also offer a phase-correct mode, where the counter starts to count downward after
+reaching TOP, until it reaches 0 again.
+
+
+```go
+var (
+	SPI0	= &SPI{
+		Bus: rp.SPI0,
+	}
+	SPI1	= &SPI{
+		Bus: rp.SPI1,
+	}
+)
+```
+
+SPI on the RP2040
+
+
+```go
+var (
+	ErrLSBNotSupported	= errors.New("SPI LSB unsupported on PL022")
+	ErrSPITimeout		= errors.New("SPI timeout")
+	ErrSPIBaud		= errors.New("SPI baud too low or above 66.5Mhz")
+	errSPIInvalidSDI	= errors.New("invalid SPI SDI pin")
+	errSPIInvalidSDO	= errors.New("invalid SPI SDO pin")
+	errSPIInvalidSCK	= errors.New("invalid SPI SCK pin")
+)
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the RP2040.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ChipVersion
+
+```go
+func ChipVersion() uint8
+```
+
+ChipVersion returns the version of the chip. 1 is returned for B0 and B1
+chip.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func CurrentCore
+
+```go
+func CurrentCore() int
+```
+
+CurrentCore returns the core number the call was made from.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of semi-random data based on ring oscillator.
+
+Unlike some other implementations of GetRNG, these random numbers are not
+cryptographically secure and must not be used for cryptographic operations
+(nonces, etc).
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC resets the ADC peripheral.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func NumCores
+
+```go
+func NumCores() int
+```
+
+NumCores returns number of cores available on the device.
+
+
+### func PWMPeripheral
+
+```go
+func PWMPeripheral(pin Pin) (sliceNum uint8, err error)
+```
+
+Peripheral returns the RP2040 PWM peripheral which ranges from 0 to 7. Each
+PWM peripheral has 2 channels, A and B which correspond to 0 and 1 in the program.
+This number corresponds to the package's PWM0 throughout PWM7 handles
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() (millicelsius int32)
+```
+
+ReadTemperature does a one-shot sample of the internal temperature sensor and returns a milli-celsius reading.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig) error
+```
+
+Configure sets the ADC pin to analog input mode.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns a one-shot ADC sample reading.
+
+
+### func (ADC) GetADCChannel
+
+```go
+func (a ADC) GetADCChannel() (c ADCChannel, err error)
+```
+
+GetADCChannel returns the channel associated with the ADC pin.
+
+
+
+
+## type ADCChannel
+
+```go
+type ADCChannel uint8
+```
+
+ADCChannel is the ADC peripheral mux channel. 0-4.
+
+
+
+### func (ADCChannel) Configure
+
+```go
+func (c ADCChannel) Configure(config ADCConfig) error
+```
+
+Configure sets the channel's associated pin to analog input mode.
+The powered on temperature sensor increases ADC_AVDD current by approximately 40 μA.
+
+
+### func (ADCChannel) Pin
+
+```go
+func (c ADCChannel) Pin() (p Pin, err error)
+```
+
+The Pin method returns the GPIO Pin associated with the ADC mux channel, if it has one.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*rp.I2C0_Type
+	mode		I2CMode
+	txInProgress	bool
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure initializes i2c peripheral and configures I2C config's pins passed.
+Here's a list of valid SDA and SCL GPIO pins on bus I2C0 of the rp2040:
+
+	SDA: 0, 4, 8, 12, 16, 20
+	SCL: 1, 5, 9, 13, 17, 21
+
+Same as above for I2C1 bus:
+
+	SDA: 2, 6, 10, 14, 18, 26
+	SCL: 3, 7, 11, 15, 19, 27
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint16) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx performs a write and then a read transfer placing the result in
+in r.
+
+Passing a nil value for w or r skips the transfer corresponding to write
+or read, respectively.
+
+	i2c.Tx(addr, nil, r)
+
+Performs only a read transfer.
+
+	i2c.Tx(addr, w, nil)
+
+Performs only a write transfer.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	// SDA/SCL Serial Data and clock pins. Refer to datasheet to see
+	// which pins match the desired bus.
+	SDA, SCL	Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure configures the gpio pin as per mode.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get reads the pin value.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set drives the pin high if value is true else drives it low.
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+PinChange represents one or more trigger events that can happen on a given GPIO pin
+on the RP2040. ORed PinChanges are valid input to most IRQ functions.
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus *rp.SPI0_Type
+}
+```
+
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup/initialize the SPI interface.
+Default baudrate of 4MHz is used if Frequency == 0. Default
+word length (data bits) is 8.
+Below is a list of GPIO pins corresponding to SPI0 bus on the rp2040:
+
+	SI : 0, 4, 17  a.k.a RX and MISO (if rp2040 is master)
+	SO : 3, 7, 19  a.k.a TX and MOSI (if rp2040 is master)
+	SCK: 2, 6, 18
+
+SPI1 bus GPIO pins:
+
+	SI : 8, 12
+	SO : 11, 15
+	SCK: 10, 14
+
+No pin configuration is needed of SCK, SDO and SDI needed after calling Configure.
+
+
+### func (*SPI) GetBaudRate
+
+```go
+func (spi *SPI) GetBaudRate() uint32
+```
+
+
+
+### func (*SPI) PrintRegs
+
+```go
+func (spi *SPI) PrintRegs()
+```
+
+PrintRegs prints SPI's peripheral common registries current values
+
+
+### func (*SPI) SetBaudRate
+
+```go
+func (spi *SPI) SetBaudRate(br uint32) error
+```
+
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Write a single byte and read a single byte from TX/RX FIFO.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) (err error)
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+Remark: This implementation (RP2040) allows reading into buffer with a custom repeated
+value on tx.
+
+	spi.Tx([]byte{0xff}, rx) // may cause unwanted heap allocations.
+
+This form sends 0xff and puts the result into rx buffer. Useful for reading from SD cards
+which require 0xff input on SI.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	// LSB not supported on rp2040.
+	LSBFirst	bool
+	// Mode's two most LSB are CPOL and CPHA. i.e. Mode==2 (0b10) is CPOL=1, CPHA=0
+	Mode	uint8
+	// Serial clock pin
+	SCK	Pin
+	// TX or Serial Data Out (MOSI if rp2040 is master)
+	SDO	Pin
+	// RX or Serial Data In (MISO if rp2040 is master)
+	SDI	Pin
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*rp.UART0_Type
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the RP2040.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the baudrate to be used for the UART.
+
+
+### func (*UART) SetFormat
+
+```go
+func (uart *UART) SetFormat(databits, stopbits uint8, parity UARTParity) error
+```
+
+SetFormat for number of data bits, stop bits, and parity for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) ClearStallEPIn
+
+```go
+func (dev *USBDevice) ClearStallEPIn(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB IN endpoint.
+
+
+### func (*USBDevice) ClearStallEPOut
+
+```go
+func (dev *USBDevice) ClearStallEPOut(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB OUT endpoint.
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+### func (*USBDevice) SetStallEPIn
+
+```go
+func (dev *USBDevice) SetStallEPIn(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB IN endpoint.
+
+
+### func (*USBDevice) SetStallEPOut
+
+```go
+func (dev *USBDevice) SetStallEPOut(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB OUT endpoint.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/pico.md b/content/docs/reference/microcontrollers/machine/pico.md
new file mode 100644
index 00000000..9aae3d66
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/pico.md
@@ -0,0 +1,1689 @@
+
+---
+title: pico
+---
+
+
+## Constants
+
+```go
+const (
+	GP0	Pin	= GPIO0
+	GP1	Pin	= GPIO1
+	GP2	Pin	= GPIO2
+	GP3	Pin	= GPIO3
+	GP4	Pin	= GPIO4
+	GP5	Pin	= GPIO5
+	GP6	Pin	= GPIO6
+	GP7	Pin	= GPIO7
+	GP8	Pin	= GPIO8
+	GP9	Pin	= GPIO9
+	GP10	Pin	= GPIO10
+	GP11	Pin	= GPIO11
+	GP12	Pin	= GPIO12
+	GP13	Pin	= GPIO13
+	GP14	Pin	= GPIO14
+	GP15	Pin	= GPIO15
+	GP16	Pin	= GPIO16
+	GP17	Pin	= GPIO17
+	GP18	Pin	= GPIO18
+	GP19	Pin	= GPIO19
+	GP20	Pin	= GPIO20
+	GP21	Pin	= GPIO21
+	GP22	Pin	= GPIO22
+	GP26	Pin	= GPIO26
+	GP27	Pin	= GPIO27
+	GP28	Pin	= GPIO28
+
+	// Onboard LED
+	LED	Pin	= GPIO25
+
+	// Onboard crystal oscillator frequency, in MHz.
+	xoscFreq	= 12	// MHz
+)
+```
+
+GPIO pins
+
+
+```go
+const (
+	I2C0_SDA_PIN	= GP4
+	I2C0_SCL_PIN	= GP5
+
+	I2C1_SDA_PIN	= GP2
+	I2C1_SCL_PIN	= GP3
+)
+```
+
+I2C Default pins on Raspberry Pico.
+
+
+```go
+const (
+	// Default Serial Clock Bus 0 for SPI communications
+	SPI0_SCK_PIN	= GPIO18
+	// Default Serial Out Bus 0 for SPI communications
+	SPI0_SDO_PIN	= GPIO19	// Tx
+	// Default Serial In Bus 0 for SPI communications
+	SPI0_SDI_PIN	= GPIO16	// Rx
+
+	// Default Serial Clock Bus 1 for SPI communications
+	SPI1_SCK_PIN	= GPIO10
+	// Default Serial Out Bus 1 for SPI communications
+	SPI1_SDO_PIN	= GPIO11	// Tx
+	// Default Serial In Bus 1 for SPI communications
+	SPI1_SDI_PIN	= GPIO12	// Rx
+)
+```
+
+SPI default pins
+
+
+```go
+const (
+	UART0_TX_PIN	= GPIO0
+	UART0_RX_PIN	= GPIO1
+	UART1_TX_PIN	= GPIO8
+	UART1_RX_PIN	= GPIO9
+	UART_TX_PIN	= UART0_TX_PIN
+	UART_RX_PIN	= UART0_RX_PIN
+)
+```
+
+UART pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	LS_SE0	= 0b00
+	LS_J	= 0b01
+	LS_K	= 0b10
+	LS_SE1	= 0b11
+)
+```
+
+
+
+```go
+const (
+	cpuFreq			= 200 * MHz
+	_NUMBANK0_GPIOS		= 30
+	_NUMBANK0_IRQS		= 4
+	_NUMIRQ			= 32
+	rp2350ExtraReg		= 0
+	RESETS_RESET_Msk	= 0x01ffffff
+	initUnreset		= rp.RESETS_RESET_ADC |
+		rp.RESETS_RESET_RTC |
+		rp.RESETS_RESET_SPI0 |
+		rp.RESETS_RESET_SPI1 |
+		rp.RESETS_RESET_UART0 |
+		rp.RESETS_RESET_UART1 |
+		rp.RESETS_RESET_USBCTRL
+	initDontReset	= rp.RESETS_RESET_IO_QSPI |
+		rp.RESETS_RESET_PADS_QSPI |
+		rp.RESETS_RESET_PLL_USB |
+		rp.RESETS_RESET_USBCTRL |
+		rp.RESETS_RESET_SYSCFG |
+		rp.RESETS_RESET_PLL_SYS
+	padEnableMask	= rp.PADS_BANK0_GPIO0_IE_Msk |
+		rp.PADS_BANK0_GPIO0_OD_Msk
+)
+```
+
+
+
+```go
+const (
+	PinOutput	PinMode	= iota
+	PinInput
+	PinInputPulldown
+	PinInputPullup
+	PinAnalog
+	PinUART
+	PinPWM
+	PinI2C
+	PinSPI
+	PinPIO0
+	PinPIO1
+)
+```
+
+
+
+```go
+const (
+	ADC0	Pin	= GPIO26
+	ADC1	Pin	= GPIO27
+	ADC2	Pin	= GPIO28
+	ADC3	Pin	= GPIO29
+
+	thermADC	= 30
+)
+```
+
+Analog pins on RP2040.
+
+
+```go
+const (
+	// Edge falling
+	PinFalling	PinChange	= 4 << iota
+	// Edge rising
+	PinRising
+
+	PinToggle	= PinFalling | PinRising
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// GPIO pins
+	GPIO0	Pin	= 0	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO1	Pin	= 1	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO2	Pin	= 2	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO3	Pin	= 3	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO4	Pin	= 4	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO5	Pin	= 5	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO6	Pin	= 6	// peripherals: PWM3 channel A, I2C1 SDA
+	GPIO7	Pin	= 7	// peripherals: PWM3 channel B, I2C1 SCL
+	GPIO8	Pin	= 8	// peripherals: PWM4 channel A, I2C0 SDA
+	GPIO9	Pin	= 9	// peripherals: PWM4 channel B, I2C0 SCL
+	GPIO10	Pin	= 10	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO11	Pin	= 11	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO12	Pin	= 12	// peripherals: PWM6 channel A, I2C0 SDA
+	GPIO13	Pin	= 13	// peripherals: PWM6 channel B, I2C0 SCL
+	GPIO14	Pin	= 14	// peripherals: PWM7 channel A, I2C1 SDA
+	GPIO15	Pin	= 15	// peripherals: PWM7 channel B, I2C1 SCL
+	GPIO16	Pin	= 16	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO17	Pin	= 17	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO18	Pin	= 18	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO19	Pin	= 19	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO20	Pin	= 20	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO21	Pin	= 21	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO22	Pin	= 22	// peripherals: PWM3 channel A
+	GPIO23	Pin	= 23	// peripherals: PWM3 channel B
+	GPIO24	Pin	= 24	// peripherals: PWM4 channel A
+	GPIO25	Pin	= 25	// peripherals: PWM4 channel B
+	GPIO26	Pin	= 26	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO27	Pin	= 27	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO28	Pin	= 28	// peripherals: PWM6 channel A
+	GPIO29	Pin	= 29	// peripherals: PWM6 channel B
+)
+```
+
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 8.3s).
+	//
+	// Nominal 1us per watchdog tick, 24-bit counter,
+	// but due to errata two ticks consumed per 1us.
+	// See: Errata RP2040-E1
+	WatchdogMaxTimeout = (rp.WATCHDOG_LOAD_LOAD_Msk / 1000) / 2
+)
+```
+
+
+
+```go
+const XOSC_STARTUP_DELAY_MULTIPLIER = 64
+```
+
+On some boards, the XOSC can take longer than usual to stabilize. On such
+boards, this is needed to avoid a hard fault on boot/reset. Refer to
+PICO_XOSC_STARTUP_DELAY_MULTIPLIER in the Pico SDK for additional details.
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	UART0	= &_UART0
+	_UART0	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART0,
+	}
+
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART1,
+	}
+)
+```
+
+UART on the RP2040
+
+
+```go
+var RTC = (*rtcType)(unsafe.Pointer(rp.RTC))
+```
+
+
+
+```go
+var (
+	ErrRtcDelayTooSmall	= errors.New("RTC interrupt deplay is too small, shall be at least 1 second")
+	ErrRtcDelayTooLarge	= errors.New("RTC interrupt deplay is too large, shall be no more than 1 day")
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	I2C0	= &_I2C0
+	_I2C0	= I2C{
+		Bus: rp.I2C0,
+	}
+	I2C1	= &_I2C1
+	_I2C1	= I2C{
+		Bus: rp.I2C1,
+	}
+)
+```
+
+I2C on the RP2040/RP2350
+
+
+```go
+var (
+	ErrBadPeriod = errors.New("period outside valid range 8ns..268ms")
+)
+```
+
+
+
+```go
+var (
+	PWM0	= getPWMGroup(0)
+	PWM1	= getPWMGroup(1)
+	PWM2	= getPWMGroup(2)
+	PWM3	= getPWMGroup(3)
+	PWM4	= getPWMGroup(4)
+	PWM5	= getPWMGroup(5)
+	PWM6	= getPWMGroup(6)
+	PWM7	= getPWMGroup(7)
+)
+```
+
+Hardware Pulse Width Modulation (PWM) API
+PWM peripherals available on RP2040. Each peripheral has 2 pins available for
+a total of 16 available PWM outputs. Some pins may not be available on some boards.
+
+The RP2040 PWM block has 8 identical slices. Each slice can drive two PWM output signals, or
+measure the frequency or duty cycle of an input signal. This gives a total of up to 16 controllable
+PWM outputs. All 30 GPIOs can be driven by the PWM block
+
+The PWM hardware functions by continuously comparing the input value to a free-running counter. This produces a
+toggling output where the amount of time spent at the high output level is proportional to the input value. The fraction of
+time spent at the high signal level is known as the duty cycle of the signal.
+
+The default behaviour of a PWM slice is to count upward until the wrap value (\ref pwm_config_set_wrap) is reached, and then
+immediately wrap to 0. PWM slices also offer a phase-correct mode, where the counter starts to count downward after
+reaching TOP, until it reaches 0 again.
+
+
+```go
+var (
+	SPI0	= &SPI{
+		Bus: rp.SPI0,
+	}
+	SPI1	= &SPI{
+		Bus: rp.SPI1,
+	}
+)
+```
+
+SPI on the RP2040
+
+
+```go
+var (
+	ErrLSBNotSupported	= errors.New("SPI LSB unsupported on PL022")
+	ErrSPITimeout		= errors.New("SPI timeout")
+	ErrSPIBaud		= errors.New("SPI baud too low or above 66.5Mhz")
+	errSPIInvalidSDI	= errors.New("invalid SPI SDI pin")
+	errSPIInvalidSDO	= errors.New("invalid SPI SDO pin")
+	errSPIInvalidSCK	= errors.New("invalid SPI SCK pin")
+)
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the RP2040.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ChipVersion
+
+```go
+func ChipVersion() uint8
+```
+
+ChipVersion returns the version of the chip. 1 is returned for B0 and B1
+chip.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func CurrentCore
+
+```go
+func CurrentCore() int
+```
+
+CurrentCore returns the core number the call was made from.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of semi-random data based on ring oscillator.
+
+Unlike some other implementations of GetRNG, these random numbers are not
+cryptographically secure and must not be used for cryptographic operations
+(nonces, etc).
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC resets the ADC peripheral.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func NumCores
+
+```go
+func NumCores() int
+```
+
+NumCores returns number of cores available on the device.
+
+
+### func PWMPeripheral
+
+```go
+func PWMPeripheral(pin Pin) (sliceNum uint8, err error)
+```
+
+Peripheral returns the RP2040 PWM peripheral which ranges from 0 to 7. Each
+PWM peripheral has 2 channels, A and B which correspond to 0 and 1 in the program.
+This number corresponds to the package's PWM0 throughout PWM7 handles
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() (millicelsius int32)
+```
+
+ReadTemperature does a one-shot sample of the internal temperature sensor and returns a milli-celsius reading.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig) error
+```
+
+Configure sets the ADC pin to analog input mode.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns a one-shot ADC sample reading.
+
+
+### func (ADC) GetADCChannel
+
+```go
+func (a ADC) GetADCChannel() (c ADCChannel, err error)
+```
+
+GetADCChannel returns the channel associated with the ADC pin.
+
+
+
+
+## type ADCChannel
+
+```go
+type ADCChannel uint8
+```
+
+ADCChannel is the ADC peripheral mux channel. 0-4.
+
+
+
+### func (ADCChannel) Configure
+
+```go
+func (c ADCChannel) Configure(config ADCConfig) error
+```
+
+Configure sets the channel's associated pin to analog input mode.
+The powered on temperature sensor increases ADC_AVDD current by approximately 40 μA.
+
+
+### func (ADCChannel) Pin
+
+```go
+func (c ADCChannel) Pin() (p Pin, err error)
+```
+
+The Pin method returns the GPIO Pin associated with the ADC mux channel, if it has one.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*rp.I2C0_Type
+	mode		I2CMode
+	txInProgress	bool
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure initializes i2c peripheral and configures I2C config's pins passed.
+Here's a list of valid SDA and SCL GPIO pins on bus I2C0 of the rp2040:
+
+	SDA: 0, 4, 8, 12, 16, 20
+	SCL: 1, 5, 9, 13, 17, 21
+
+Same as above for I2C1 bus:
+
+	SDA: 2, 6, 10, 14, 18, 26
+	SCL: 3, 7, 11, 15, 19, 27
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint16) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx performs a write and then a read transfer placing the result in
+in r.
+
+Passing a nil value for w or r skips the transfer corresponding to write
+or read, respectively.
+
+	i2c.Tx(addr, nil, r)
+
+Performs only a read transfer.
+
+	i2c.Tx(addr, w, nil)
+
+Performs only a write transfer.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	// SDA/SCL Serial Data and clock pins. Refer to datasheet to see
+	// which pins match the desired bus.
+	SDA, SCL	Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure configures the gpio pin as per mode.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get reads the pin value.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set drives the pin high if value is true else drives it low.
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+PinChange represents one or more trigger events that can happen on a given GPIO pin
+on the RP2040. ORed PinChanges are valid input to most IRQ functions.
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus *rp.SPI0_Type
+}
+```
+
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup/initialize the SPI interface.
+Default baudrate of 4MHz is used if Frequency == 0. Default
+word length (data bits) is 8.
+Below is a list of GPIO pins corresponding to SPI0 bus on the rp2040:
+
+	SI : 0, 4, 17  a.k.a RX and MISO (if rp2040 is master)
+	SO : 3, 7, 19  a.k.a TX and MOSI (if rp2040 is master)
+	SCK: 2, 6, 18
+
+SPI1 bus GPIO pins:
+
+	SI : 8, 12
+	SO : 11, 15
+	SCK: 10, 14
+
+No pin configuration is needed of SCK, SDO and SDI needed after calling Configure.
+
+
+### func (*SPI) GetBaudRate
+
+```go
+func (spi *SPI) GetBaudRate() uint32
+```
+
+
+
+### func (*SPI) PrintRegs
+
+```go
+func (spi *SPI) PrintRegs()
+```
+
+PrintRegs prints SPI's peripheral common registries current values
+
+
+### func (*SPI) SetBaudRate
+
+```go
+func (spi *SPI) SetBaudRate(br uint32) error
+```
+
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Write a single byte and read a single byte from TX/RX FIFO.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) (err error)
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+Remark: This implementation (RP2040) allows reading into buffer with a custom repeated
+value on tx.
+
+	spi.Tx([]byte{0xff}, rx) // may cause unwanted heap allocations.
+
+This form sends 0xff and puts the result into rx buffer. Useful for reading from SD cards
+which require 0xff input on SI.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	// LSB not supported on rp2040.
+	LSBFirst	bool
+	// Mode's two most LSB are CPOL and CPHA. i.e. Mode==2 (0b10) is CPOL=1, CPHA=0
+	Mode	uint8
+	// Serial clock pin
+	SCK	Pin
+	// TX or Serial Data Out (MOSI if rp2040 is master)
+	SDO	Pin
+	// RX or Serial Data In (MISO if rp2040 is master)
+	SDI	Pin
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*rp.UART0_Type
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the RP2040.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the baudrate to be used for the UART.
+
+
+### func (*UART) SetFormat
+
+```go
+func (uart *UART) SetFormat(databits, stopbits uint8, parity UARTParity) error
+```
+
+SetFormat for number of data bits, stop bits, and parity for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) ClearStallEPIn
+
+```go
+func (dev *USBDevice) ClearStallEPIn(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB IN endpoint.
+
+
+### func (*USBDevice) ClearStallEPOut
+
+```go
+func (dev *USBDevice) ClearStallEPOut(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB OUT endpoint.
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+### func (*USBDevice) SetStallEPIn
+
+```go
+func (dev *USBDevice) SetStallEPIn(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB IN endpoint.
+
+
+### func (*USBDevice) SetStallEPOut
+
+```go
+func (dev *USBDevice) SetStallEPOut(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB OUT endpoint.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/pico2-w.md b/content/docs/reference/microcontrollers/machine/pico2-w.md
new file mode 100644
index 00000000..e31bbcf3
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/pico2-w.md
@@ -0,0 +1,1685 @@
+
+---
+title: pico2-w
+---
+
+
+## Constants
+
+```go
+const (
+	GP0	Pin	= GPIO0
+	GP1	Pin	= GPIO1
+	GP2	Pin	= GPIO2
+	GP3	Pin	= GPIO3
+	GP4	Pin	= GPIO4
+	GP5	Pin	= GPIO5
+	GP6	Pin	= GPIO6
+	GP7	Pin	= GPIO7
+	GP8	Pin	= GPIO8
+	GP9	Pin	= GPIO9
+	GP10	Pin	= GPIO10
+	GP11	Pin	= GPIO11
+	GP12	Pin	= GPIO12
+	GP13	Pin	= GPIO13
+	GP14	Pin	= GPIO14
+	GP15	Pin	= GPIO15
+	GP16	Pin	= GPIO16
+	GP17	Pin	= GPIO17
+	GP18	Pin	= GPIO18
+	GP19	Pin	= GPIO19
+	GP20	Pin	= GPIO20
+	GP21	Pin	= GPIO21
+	GP22	Pin	= GPIO22
+	GP26	Pin	= GPIO26
+	GP27	Pin	= GPIO27
+	GP28	Pin	= GPIO28
+
+	// Onboard LED
+	LED	Pin	= GPIO25
+
+	// Onboard crystal oscillator frequency, in MHz.
+	xoscFreq	= 12	// MHz
+)
+```
+
+GPIO pins
+
+
+```go
+const (
+	I2C0_SDA_PIN	= GP4
+	I2C0_SCL_PIN	= GP5
+
+	I2C1_SDA_PIN	= GP2
+	I2C1_SCL_PIN	= GP3
+)
+```
+
+I2C Default pins on Raspberry Pico.
+
+
+```go
+const (
+	// Default Serial Clock Bus 0 for SPI communications
+	SPI0_SCK_PIN	= GPIO18
+	// Default Serial Out Bus 0 for SPI communications
+	SPI0_SDO_PIN	= GPIO19	// Tx
+	// Default Serial In Bus 0 for SPI communications
+	SPI0_SDI_PIN	= GPIO16	// Rx
+
+	// Default Serial Clock Bus 1 for SPI communications
+	SPI1_SCK_PIN	= GPIO10
+	// Default Serial Out Bus 1 for SPI communications
+	SPI1_SDO_PIN	= GPIO11	// Tx
+	// Default Serial In Bus 1 for SPI communications
+	SPI1_SDI_PIN	= GPIO12	// Rx
+)
+```
+
+SPI default pins
+
+
+```go
+const (
+	UART0_TX_PIN	= GPIO0
+	UART0_RX_PIN	= GPIO1
+	UART1_TX_PIN	= GPIO8
+	UART1_RX_PIN	= GPIO9
+	UART_TX_PIN	= UART0_TX_PIN
+	UART_RX_PIN	= UART0_RX_PIN
+)
+```
+
+UART pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	cpuFreq			= 150 * MHz
+	_NUMBANK0_GPIOS		= 48
+	_NUMBANK0_IRQS		= 6
+	rp2350ExtraReg		= 1
+	_NUMIRQ			= 51
+	notimpl			= "rp2350: not implemented"
+	RESETS_RESET_Msk	= 0x1fffffff
+	initUnreset		= rp.RESETS_RESET_ADC |
+		rp.RESETS_RESET_SPI0 |
+		rp.RESETS_RESET_SPI1 |
+		rp.RESETS_RESET_UART0 |
+		rp.RESETS_RESET_UART1 |
+		rp.RESETS_RESET_USBCTRL
+	initDontReset	= rp.RESETS_RESET_USBCTRL |
+		rp.RESETS_RESET_SYSCFG |
+		rp.RESETS_RESET_PLL_USB |
+		rp.RESETS_RESET_PLL_SYS |
+		rp.RESETS_RESET_PADS_QSPI |
+		rp.RESETS_RESET_IO_QSPI |
+		rp.RESETS_RESET_JTAG
+	padEnableMask	= rp.PADS_BANK0_GPIO0_IE_Msk |
+		rp.PADS_BANK0_GPIO0_OD_Msk |
+		rp.PADS_BANK0_GPIO0_ISO_Msk
+)
+```
+
+
+
+```go
+const (
+	PinOutput	PinMode	= iota
+	PinInput
+	PinInputPulldown
+	PinInputPullup
+	PinAnalog
+	PinUART
+	PinPWM
+	PinI2C
+	PinSPI
+	PinPIO0
+	PinPIO1
+	PinPIO2
+)
+```
+
+
+
+```go
+const (
+	clkGPOUT0	clockIndex	= iota	// GPIO Muxing 0
+	clkGPOUT1				// GPIO Muxing 1
+	clkGPOUT2				// GPIO Muxing 2
+	clkGPOUT3				// GPIO Muxing 3
+	clkRef					// Watchdog and timers reference clock
+	clkSys					// Processors, bus fabric, memory, memory mapped registers
+	clkPeri					// Peripheral clock for UART and SPI
+	ClkHSTX					// High speed interface
+	clkUSB					// USB clock
+	clkADC					// ADC clock
+	numClocks
+)
+```
+
+
+
+```go
+const (
+	ADC0	Pin	= GPIO26
+	ADC1	Pin	= GPIO27
+	ADC2	Pin	= GPIO28
+	ADC3	Pin	= GPIO29
+
+	// fifth ADC channel.
+	thermADC	= 30
+)
+```
+
+Analog pins on RP2350a.
+
+
+```go
+const (
+	// Edge falling
+	PinFalling	PinChange	= 4 << iota
+	// Edge rising
+	PinRising
+
+	PinToggle	= PinFalling | PinRising
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// GPIO pins
+	GPIO0	Pin	= 0	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO1	Pin	= 1	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO2	Pin	= 2	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO3	Pin	= 3	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO4	Pin	= 4	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO5	Pin	= 5	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO6	Pin	= 6	// peripherals: PWM3 channel A, I2C1 SDA
+	GPIO7	Pin	= 7	// peripherals: PWM3 channel B, I2C1 SCL
+	GPIO8	Pin	= 8	// peripherals: PWM4 channel A, I2C0 SDA
+	GPIO9	Pin	= 9	// peripherals: PWM4 channel B, I2C0 SCL
+	GPIO10	Pin	= 10	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO11	Pin	= 11	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO12	Pin	= 12	// peripherals: PWM6 channel A, I2C0 SDA
+	GPIO13	Pin	= 13	// peripherals: PWM6 channel B, I2C0 SCL
+	GPIO14	Pin	= 14	// peripherals: PWM7 channel A, I2C1 SDA
+	GPIO15	Pin	= 15	// peripherals: PWM7 channel B, I2C1 SCL
+	GPIO16	Pin	= 16	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO17	Pin	= 17	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO18	Pin	= 18	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO19	Pin	= 19	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO20	Pin	= 20	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO21	Pin	= 21	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO22	Pin	= 22	// peripherals: PWM3 channel A
+	GPIO23	Pin	= 23	// peripherals: PWM3 channel B
+	GPIO24	Pin	= 24	// peripherals: PWM4 channel A
+	GPIO25	Pin	= 25	// peripherals: PWM4 channel B
+	GPIO26	Pin	= 26	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO27	Pin	= 27	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO28	Pin	= 28	// peripherals: PWM6 channel A
+	GPIO29	Pin	= 29	// peripherals: PWM6 channel B
+)
+```
+
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 8.3s).
+	//
+	// Nominal 1us per watchdog tick, 24-bit counter,
+	// but due to errata two ticks consumed per 1us.
+	// See: Errata RP2040-E1
+	WatchdogMaxTimeout = (rp.WATCHDOG_LOAD_LOAD_Msk / 1000) / 2
+)
+```
+
+
+
+```go
+const XOSC_STARTUP_DELAY_MULTIPLIER = 64
+```
+
+On some boards, the XOSC can take longer than usual to stabilize. On such
+boards, this is needed to avoid a hard fault on boot/reset. Refer to
+PICO_XOSC_STARTUP_DELAY_MULTIPLIER in the Pico SDK for additional details.
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	UART0	= &_UART0
+	_UART0	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART0,
+	}
+
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART1,
+	}
+)
+```
+
+UART on the RP2040
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	I2C0	= &_I2C0
+	_I2C0	= I2C{
+		Bus: rp.I2C0,
+	}
+	I2C1	= &_I2C1
+	_I2C1	= I2C{
+		Bus: rp.I2C1,
+	}
+)
+```
+
+I2C on the RP2040/RP2350
+
+
+```go
+var (
+	ErrBadPeriod = errors.New("period outside valid range 8ns..268ms")
+)
+```
+
+
+
+```go
+var (
+	PWM0	= getPWMGroup(0)
+	PWM1	= getPWMGroup(1)
+	PWM2	= getPWMGroup(2)
+	PWM3	= getPWMGroup(3)
+	PWM4	= getPWMGroup(4)
+	PWM5	= getPWMGroup(5)
+	PWM6	= getPWMGroup(6)
+	PWM7	= getPWMGroup(7)
+)
+```
+
+Hardware Pulse Width Modulation (PWM) API
+PWM peripherals available on RP2040. Each peripheral has 2 pins available for
+a total of 16 available PWM outputs. Some pins may not be available on some boards.
+
+The RP2040 PWM block has 8 identical slices. Each slice can drive two PWM output signals, or
+measure the frequency or duty cycle of an input signal. This gives a total of up to 16 controllable
+PWM outputs. All 30 GPIOs can be driven by the PWM block
+
+The PWM hardware functions by continuously comparing the input value to a free-running counter. This produces a
+toggling output where the amount of time spent at the high output level is proportional to the input value. The fraction of
+time spent at the high signal level is known as the duty cycle of the signal.
+
+The default behaviour of a PWM slice is to count upward until the wrap value (\ref pwm_config_set_wrap) is reached, and then
+immediately wrap to 0. PWM slices also offer a phase-correct mode, where the counter starts to count downward after
+reaching TOP, until it reaches 0 again.
+
+
+```go
+var (
+	SPI0	= &SPI{
+		Bus: rp.SPI0,
+	}
+	SPI1	= &SPI{
+		Bus: rp.SPI1,
+	}
+)
+```
+
+SPI on the RP2040
+
+
+```go
+var (
+	ErrLSBNotSupported	= errors.New("SPI LSB unsupported on PL022")
+	ErrSPITimeout		= errors.New("SPI timeout")
+	ErrSPIBaud		= errors.New("SPI baud too low or above 66.5Mhz")
+	errSPIInvalidSDI	= errors.New("invalid SPI SDI pin")
+	errSPIInvalidSDO	= errors.New("invalid SPI SDO pin")
+	errSPIInvalidSCK	= errors.New("invalid SPI SCK pin")
+)
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the RP2040.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ChipVersion
+
+```go
+func ChipVersion() uint8
+```
+
+ChipVersion returns the version of the chip. 1 is returned for B0 and B1
+chip.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func CurrentCore
+
+```go
+func CurrentCore() int
+```
+
+CurrentCore returns the core number the call was made from.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of semi-random data based on ring oscillator.
+
+Unlike some other implementations of GetRNG, these random numbers are not
+cryptographically secure and must not be used for cryptographic operations
+(nonces, etc).
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC resets the ADC peripheral.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func NumCores
+
+```go
+func NumCores() int
+```
+
+NumCores returns number of cores available on the device.
+
+
+### func PWMPeripheral
+
+```go
+func PWMPeripheral(pin Pin) (sliceNum uint8, err error)
+```
+
+Peripheral returns the RP2040 PWM peripheral which ranges from 0 to 7. Each
+PWM peripheral has 2 channels, A and B which correspond to 0 and 1 in the program.
+This number corresponds to the package's PWM0 throughout PWM7 handles
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() (millicelsius int32)
+```
+
+ReadTemperature does a one-shot sample of the internal temperature sensor and returns a milli-celsius reading.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig) error
+```
+
+Configure sets the ADC pin to analog input mode.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns a one-shot ADC sample reading.
+
+
+### func (ADC) GetADCChannel
+
+```go
+func (a ADC) GetADCChannel() (c ADCChannel, err error)
+```
+
+GetADCChannel returns the channel associated with the ADC pin.
+
+
+
+
+## type ADCChannel
+
+```go
+type ADCChannel uint8
+```
+
+ADCChannel is the ADC peripheral mux channel. 0-4.
+
+
+
+### func (ADCChannel) Configure
+
+```go
+func (c ADCChannel) Configure(config ADCConfig) error
+```
+
+Configure sets the channel's associated pin to analog input mode.
+The powered on temperature sensor increases ADC_AVDD current by approximately 40 μA.
+
+
+### func (ADCChannel) Pin
+
+```go
+func (c ADCChannel) Pin() (p Pin, err error)
+```
+
+The Pin method returns the GPIO Pin associated with the ADC mux channel, if it has one.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*rp.I2C0_Type
+	mode		I2CMode
+	txInProgress	bool
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure initializes i2c peripheral and configures I2C config's pins passed.
+Here's a list of valid SDA and SCL GPIO pins on bus I2C0 of the rp2040:
+
+	SDA: 0, 4, 8, 12, 16, 20
+	SCL: 1, 5, 9, 13, 17, 21
+
+Same as above for I2C1 bus:
+
+	SDA: 2, 6, 10, 14, 18, 26
+	SCL: 3, 7, 11, 15, 19, 27
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint16) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx performs a write and then a read transfer placing the result in
+in r.
+
+Passing a nil value for w or r skips the transfer corresponding to write
+or read, respectively.
+
+	i2c.Tx(addr, nil, r)
+
+Performs only a read transfer.
+
+	i2c.Tx(addr, w, nil)
+
+Performs only a write transfer.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	// SDA/SCL Serial Data and clock pins. Refer to datasheet to see
+	// which pins match the desired bus.
+	SDA, SCL	Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure configures the gpio pin as per mode.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get reads the pin value.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set drives the pin high if value is true else drives it low.
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+PinChange represents one or more trigger events that can happen on a given GPIO pin
+on the RP2040. ORed PinChanges are valid input to most IRQ functions.
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus *rp.SPI0_Type
+}
+```
+
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup/initialize the SPI interface.
+Default baudrate of 4MHz is used if Frequency == 0. Default
+word length (data bits) is 8.
+Below is a list of GPIO pins corresponding to SPI0 bus on the rp2040:
+
+	SI : 0, 4, 17  a.k.a RX and MISO (if rp2040 is master)
+	SO : 3, 7, 19  a.k.a TX and MOSI (if rp2040 is master)
+	SCK: 2, 6, 18
+
+SPI1 bus GPIO pins:
+
+	SI : 8, 12
+	SO : 11, 15
+	SCK: 10, 14
+
+No pin configuration is needed of SCK, SDO and SDI needed after calling Configure.
+
+
+### func (*SPI) GetBaudRate
+
+```go
+func (spi *SPI) GetBaudRate() uint32
+```
+
+
+
+### func (*SPI) PrintRegs
+
+```go
+func (spi *SPI) PrintRegs()
+```
+
+PrintRegs prints SPI's peripheral common registries current values
+
+
+### func (*SPI) SetBaudRate
+
+```go
+func (spi *SPI) SetBaudRate(br uint32) error
+```
+
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Write a single byte and read a single byte from TX/RX FIFO.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) (err error)
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+Remark: This implementation (RP2040) allows reading into buffer with a custom repeated
+value on tx.
+
+	spi.Tx([]byte{0xff}, rx) // may cause unwanted heap allocations.
+
+This form sends 0xff and puts the result into rx buffer. Useful for reading from SD cards
+which require 0xff input on SI.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	// LSB not supported on rp2040.
+	LSBFirst	bool
+	// Mode's two most LSB are CPOL and CPHA. i.e. Mode==2 (0b10) is CPOL=1, CPHA=0
+	Mode	uint8
+	// Serial clock pin
+	SCK	Pin
+	// TX or Serial Data Out (MOSI if rp2040 is master)
+	SDO	Pin
+	// RX or Serial Data In (MISO if rp2040 is master)
+	SDI	Pin
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*rp.UART0_Type
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the RP2040.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the baudrate to be used for the UART.
+
+
+### func (*UART) SetFormat
+
+```go
+func (uart *UART) SetFormat(databits, stopbits uint8, parity UARTParity) error
+```
+
+SetFormat for number of data bits, stop bits, and parity for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) ClearStallEPIn
+
+```go
+func (dev *USBDevice) ClearStallEPIn(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB IN endpoint.
+
+
+### func (*USBDevice) ClearStallEPOut
+
+```go
+func (dev *USBDevice) ClearStallEPOut(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB OUT endpoint.
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+### func (*USBDevice) SetStallEPIn
+
+```go
+func (dev *USBDevice) SetStallEPIn(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB IN endpoint.
+
+
+### func (*USBDevice) SetStallEPOut
+
+```go
+func (dev *USBDevice) SetStallEPOut(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB OUT endpoint.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/pico2.md b/content/docs/reference/microcontrollers/machine/pico2.md
new file mode 100644
index 00000000..40e50ca8
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/pico2.md
@@ -0,0 +1,1685 @@
+
+---
+title: pico2
+---
+
+
+## Constants
+
+```go
+const (
+	GP0	Pin	= GPIO0
+	GP1	Pin	= GPIO1
+	GP2	Pin	= GPIO2
+	GP3	Pin	= GPIO3
+	GP4	Pin	= GPIO4
+	GP5	Pin	= GPIO5
+	GP6	Pin	= GPIO6
+	GP7	Pin	= GPIO7
+	GP8	Pin	= GPIO8
+	GP9	Pin	= GPIO9
+	GP10	Pin	= GPIO10
+	GP11	Pin	= GPIO11
+	GP12	Pin	= GPIO12
+	GP13	Pin	= GPIO13
+	GP14	Pin	= GPIO14
+	GP15	Pin	= GPIO15
+	GP16	Pin	= GPIO16
+	GP17	Pin	= GPIO17
+	GP18	Pin	= GPIO18
+	GP19	Pin	= GPIO19
+	GP20	Pin	= GPIO20
+	GP21	Pin	= GPIO21
+	GP22	Pin	= GPIO22
+	GP26	Pin	= GPIO26
+	GP27	Pin	= GPIO27
+	GP28	Pin	= GPIO28
+
+	// Onboard LED
+	LED	Pin	= GPIO25
+
+	// Onboard crystal oscillator frequency, in MHz.
+	xoscFreq	= 12	// MHz
+)
+```
+
+GPIO pins
+
+
+```go
+const (
+	I2C0_SDA_PIN	= GP4
+	I2C0_SCL_PIN	= GP5
+
+	I2C1_SDA_PIN	= GP2
+	I2C1_SCL_PIN	= GP3
+)
+```
+
+I2C Default pins on Raspberry Pico.
+
+
+```go
+const (
+	// Default Serial Clock Bus 0 for SPI communications
+	SPI0_SCK_PIN	= GPIO18
+	// Default Serial Out Bus 0 for SPI communications
+	SPI0_SDO_PIN	= GPIO19	// Tx
+	// Default Serial In Bus 0 for SPI communications
+	SPI0_SDI_PIN	= GPIO16	// Rx
+
+	// Default Serial Clock Bus 1 for SPI communications
+	SPI1_SCK_PIN	= GPIO10
+	// Default Serial Out Bus 1 for SPI communications
+	SPI1_SDO_PIN	= GPIO11	// Tx
+	// Default Serial In Bus 1 for SPI communications
+	SPI1_SDI_PIN	= GPIO12	// Rx
+)
+```
+
+SPI default pins
+
+
+```go
+const (
+	UART0_TX_PIN	= GPIO0
+	UART0_RX_PIN	= GPIO1
+	UART1_TX_PIN	= GPIO8
+	UART1_RX_PIN	= GPIO9
+	UART_TX_PIN	= UART0_TX_PIN
+	UART_RX_PIN	= UART0_RX_PIN
+)
+```
+
+UART pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	cpuFreq			= 150 * MHz
+	_NUMBANK0_GPIOS		= 48
+	_NUMBANK0_IRQS		= 6
+	rp2350ExtraReg		= 1
+	_NUMIRQ			= 51
+	notimpl			= "rp2350: not implemented"
+	RESETS_RESET_Msk	= 0x1fffffff
+	initUnreset		= rp.RESETS_RESET_ADC |
+		rp.RESETS_RESET_SPI0 |
+		rp.RESETS_RESET_SPI1 |
+		rp.RESETS_RESET_UART0 |
+		rp.RESETS_RESET_UART1 |
+		rp.RESETS_RESET_USBCTRL
+	initDontReset	= rp.RESETS_RESET_USBCTRL |
+		rp.RESETS_RESET_SYSCFG |
+		rp.RESETS_RESET_PLL_USB |
+		rp.RESETS_RESET_PLL_SYS |
+		rp.RESETS_RESET_PADS_QSPI |
+		rp.RESETS_RESET_IO_QSPI |
+		rp.RESETS_RESET_JTAG
+	padEnableMask	= rp.PADS_BANK0_GPIO0_IE_Msk |
+		rp.PADS_BANK0_GPIO0_OD_Msk |
+		rp.PADS_BANK0_GPIO0_ISO_Msk
+)
+```
+
+
+
+```go
+const (
+	PinOutput	PinMode	= iota
+	PinInput
+	PinInputPulldown
+	PinInputPullup
+	PinAnalog
+	PinUART
+	PinPWM
+	PinI2C
+	PinSPI
+	PinPIO0
+	PinPIO1
+	PinPIO2
+)
+```
+
+
+
+```go
+const (
+	clkGPOUT0	clockIndex	= iota	// GPIO Muxing 0
+	clkGPOUT1				// GPIO Muxing 1
+	clkGPOUT2				// GPIO Muxing 2
+	clkGPOUT3				// GPIO Muxing 3
+	clkRef					// Watchdog and timers reference clock
+	clkSys					// Processors, bus fabric, memory, memory mapped registers
+	clkPeri					// Peripheral clock for UART and SPI
+	ClkHSTX					// High speed interface
+	clkUSB					// USB clock
+	clkADC					// ADC clock
+	numClocks
+)
+```
+
+
+
+```go
+const (
+	ADC0	Pin	= GPIO26
+	ADC1	Pin	= GPIO27
+	ADC2	Pin	= GPIO28
+	ADC3	Pin	= GPIO29
+
+	// fifth ADC channel.
+	thermADC	= 30
+)
+```
+
+Analog pins on RP2350a.
+
+
+```go
+const (
+	// Edge falling
+	PinFalling	PinChange	= 4 << iota
+	// Edge rising
+	PinRising
+
+	PinToggle	= PinFalling | PinRising
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// GPIO pins
+	GPIO0	Pin	= 0	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO1	Pin	= 1	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO2	Pin	= 2	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO3	Pin	= 3	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO4	Pin	= 4	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO5	Pin	= 5	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO6	Pin	= 6	// peripherals: PWM3 channel A, I2C1 SDA
+	GPIO7	Pin	= 7	// peripherals: PWM3 channel B, I2C1 SCL
+	GPIO8	Pin	= 8	// peripherals: PWM4 channel A, I2C0 SDA
+	GPIO9	Pin	= 9	// peripherals: PWM4 channel B, I2C0 SCL
+	GPIO10	Pin	= 10	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO11	Pin	= 11	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO12	Pin	= 12	// peripherals: PWM6 channel A, I2C0 SDA
+	GPIO13	Pin	= 13	// peripherals: PWM6 channel B, I2C0 SCL
+	GPIO14	Pin	= 14	// peripherals: PWM7 channel A, I2C1 SDA
+	GPIO15	Pin	= 15	// peripherals: PWM7 channel B, I2C1 SCL
+	GPIO16	Pin	= 16	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO17	Pin	= 17	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO18	Pin	= 18	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO19	Pin	= 19	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO20	Pin	= 20	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO21	Pin	= 21	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO22	Pin	= 22	// peripherals: PWM3 channel A
+	GPIO23	Pin	= 23	// peripherals: PWM3 channel B
+	GPIO24	Pin	= 24	// peripherals: PWM4 channel A
+	GPIO25	Pin	= 25	// peripherals: PWM4 channel B
+	GPIO26	Pin	= 26	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO27	Pin	= 27	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO28	Pin	= 28	// peripherals: PWM6 channel A
+	GPIO29	Pin	= 29	// peripherals: PWM6 channel B
+)
+```
+
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 8.3s).
+	//
+	// Nominal 1us per watchdog tick, 24-bit counter,
+	// but due to errata two ticks consumed per 1us.
+	// See: Errata RP2040-E1
+	WatchdogMaxTimeout = (rp.WATCHDOG_LOAD_LOAD_Msk / 1000) / 2
+)
+```
+
+
+
+```go
+const XOSC_STARTUP_DELAY_MULTIPLIER = 64
+```
+
+On some boards, the XOSC can take longer than usual to stabilize. On such
+boards, this is needed to avoid a hard fault on boot/reset. Refer to
+PICO_XOSC_STARTUP_DELAY_MULTIPLIER in the Pico SDK for additional details.
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	UART0	= &_UART0
+	_UART0	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART0,
+	}
+
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART1,
+	}
+)
+```
+
+UART on the RP2040
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	I2C0	= &_I2C0
+	_I2C0	= I2C{
+		Bus: rp.I2C0,
+	}
+	I2C1	= &_I2C1
+	_I2C1	= I2C{
+		Bus: rp.I2C1,
+	}
+)
+```
+
+I2C on the RP2040/RP2350
+
+
+```go
+var (
+	ErrBadPeriod = errors.New("period outside valid range 8ns..268ms")
+)
+```
+
+
+
+```go
+var (
+	PWM0	= getPWMGroup(0)
+	PWM1	= getPWMGroup(1)
+	PWM2	= getPWMGroup(2)
+	PWM3	= getPWMGroup(3)
+	PWM4	= getPWMGroup(4)
+	PWM5	= getPWMGroup(5)
+	PWM6	= getPWMGroup(6)
+	PWM7	= getPWMGroup(7)
+)
+```
+
+Hardware Pulse Width Modulation (PWM) API
+PWM peripherals available on RP2040. Each peripheral has 2 pins available for
+a total of 16 available PWM outputs. Some pins may not be available on some boards.
+
+The RP2040 PWM block has 8 identical slices. Each slice can drive two PWM output signals, or
+measure the frequency or duty cycle of an input signal. This gives a total of up to 16 controllable
+PWM outputs. All 30 GPIOs can be driven by the PWM block
+
+The PWM hardware functions by continuously comparing the input value to a free-running counter. This produces a
+toggling output where the amount of time spent at the high output level is proportional to the input value. The fraction of
+time spent at the high signal level is known as the duty cycle of the signal.
+
+The default behaviour of a PWM slice is to count upward until the wrap value (\ref pwm_config_set_wrap) is reached, and then
+immediately wrap to 0. PWM slices also offer a phase-correct mode, where the counter starts to count downward after
+reaching TOP, until it reaches 0 again.
+
+
+```go
+var (
+	SPI0	= &SPI{
+		Bus: rp.SPI0,
+	}
+	SPI1	= &SPI{
+		Bus: rp.SPI1,
+	}
+)
+```
+
+SPI on the RP2040
+
+
+```go
+var (
+	ErrLSBNotSupported	= errors.New("SPI LSB unsupported on PL022")
+	ErrSPITimeout		= errors.New("SPI timeout")
+	ErrSPIBaud		= errors.New("SPI baud too low or above 66.5Mhz")
+	errSPIInvalidSDI	= errors.New("invalid SPI SDI pin")
+	errSPIInvalidSDO	= errors.New("invalid SPI SDO pin")
+	errSPIInvalidSCK	= errors.New("invalid SPI SCK pin")
+)
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the RP2040.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ChipVersion
+
+```go
+func ChipVersion() uint8
+```
+
+ChipVersion returns the version of the chip. 1 is returned for B0 and B1
+chip.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func CurrentCore
+
+```go
+func CurrentCore() int
+```
+
+CurrentCore returns the core number the call was made from.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of semi-random data based on ring oscillator.
+
+Unlike some other implementations of GetRNG, these random numbers are not
+cryptographically secure and must not be used for cryptographic operations
+(nonces, etc).
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC resets the ADC peripheral.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func NumCores
+
+```go
+func NumCores() int
+```
+
+NumCores returns number of cores available on the device.
+
+
+### func PWMPeripheral
+
+```go
+func PWMPeripheral(pin Pin) (sliceNum uint8, err error)
+```
+
+Peripheral returns the RP2040 PWM peripheral which ranges from 0 to 7. Each
+PWM peripheral has 2 channels, A and B which correspond to 0 and 1 in the program.
+This number corresponds to the package's PWM0 throughout PWM7 handles
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() (millicelsius int32)
+```
+
+ReadTemperature does a one-shot sample of the internal temperature sensor and returns a milli-celsius reading.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig) error
+```
+
+Configure sets the ADC pin to analog input mode.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns a one-shot ADC sample reading.
+
+
+### func (ADC) GetADCChannel
+
+```go
+func (a ADC) GetADCChannel() (c ADCChannel, err error)
+```
+
+GetADCChannel returns the channel associated with the ADC pin.
+
+
+
+
+## type ADCChannel
+
+```go
+type ADCChannel uint8
+```
+
+ADCChannel is the ADC peripheral mux channel. 0-4.
+
+
+
+### func (ADCChannel) Configure
+
+```go
+func (c ADCChannel) Configure(config ADCConfig) error
+```
+
+Configure sets the channel's associated pin to analog input mode.
+The powered on temperature sensor increases ADC_AVDD current by approximately 40 μA.
+
+
+### func (ADCChannel) Pin
+
+```go
+func (c ADCChannel) Pin() (p Pin, err error)
+```
+
+The Pin method returns the GPIO Pin associated with the ADC mux channel, if it has one.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*rp.I2C0_Type
+	mode		I2CMode
+	txInProgress	bool
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure initializes i2c peripheral and configures I2C config's pins passed.
+Here's a list of valid SDA and SCL GPIO pins on bus I2C0 of the rp2040:
+
+	SDA: 0, 4, 8, 12, 16, 20
+	SCL: 1, 5, 9, 13, 17, 21
+
+Same as above for I2C1 bus:
+
+	SDA: 2, 6, 10, 14, 18, 26
+	SCL: 3, 7, 11, 15, 19, 27
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint16) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx performs a write and then a read transfer placing the result in
+in r.
+
+Passing a nil value for w or r skips the transfer corresponding to write
+or read, respectively.
+
+	i2c.Tx(addr, nil, r)
+
+Performs only a read transfer.
+
+	i2c.Tx(addr, w, nil)
+
+Performs only a write transfer.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	// SDA/SCL Serial Data and clock pins. Refer to datasheet to see
+	// which pins match the desired bus.
+	SDA, SCL	Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure configures the gpio pin as per mode.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get reads the pin value.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set drives the pin high if value is true else drives it low.
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+PinChange represents one or more trigger events that can happen on a given GPIO pin
+on the RP2040. ORed PinChanges are valid input to most IRQ functions.
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus *rp.SPI0_Type
+}
+```
+
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup/initialize the SPI interface.
+Default baudrate of 4MHz is used if Frequency == 0. Default
+word length (data bits) is 8.
+Below is a list of GPIO pins corresponding to SPI0 bus on the rp2040:
+
+	SI : 0, 4, 17  a.k.a RX and MISO (if rp2040 is master)
+	SO : 3, 7, 19  a.k.a TX and MOSI (if rp2040 is master)
+	SCK: 2, 6, 18
+
+SPI1 bus GPIO pins:
+
+	SI : 8, 12
+	SO : 11, 15
+	SCK: 10, 14
+
+No pin configuration is needed of SCK, SDO and SDI needed after calling Configure.
+
+
+### func (*SPI) GetBaudRate
+
+```go
+func (spi *SPI) GetBaudRate() uint32
+```
+
+
+
+### func (*SPI) PrintRegs
+
+```go
+func (spi *SPI) PrintRegs()
+```
+
+PrintRegs prints SPI's peripheral common registries current values
+
+
+### func (*SPI) SetBaudRate
+
+```go
+func (spi *SPI) SetBaudRate(br uint32) error
+```
+
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Write a single byte and read a single byte from TX/RX FIFO.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) (err error)
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+Remark: This implementation (RP2040) allows reading into buffer with a custom repeated
+value on tx.
+
+	spi.Tx([]byte{0xff}, rx) // may cause unwanted heap allocations.
+
+This form sends 0xff and puts the result into rx buffer. Useful for reading from SD cards
+which require 0xff input on SI.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	// LSB not supported on rp2040.
+	LSBFirst	bool
+	// Mode's two most LSB are CPOL and CPHA. i.e. Mode==2 (0b10) is CPOL=1, CPHA=0
+	Mode	uint8
+	// Serial clock pin
+	SCK	Pin
+	// TX or Serial Data Out (MOSI if rp2040 is master)
+	SDO	Pin
+	// RX or Serial Data In (MISO if rp2040 is master)
+	SDI	Pin
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*rp.UART0_Type
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the RP2040.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the baudrate to be used for the UART.
+
+
+### func (*UART) SetFormat
+
+```go
+func (uart *UART) SetFormat(databits, stopbits uint8, parity UARTParity) error
+```
+
+SetFormat for number of data bits, stop bits, and parity for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) ClearStallEPIn
+
+```go
+func (dev *USBDevice) ClearStallEPIn(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB IN endpoint.
+
+
+### func (*USBDevice) ClearStallEPOut
+
+```go
+func (dev *USBDevice) ClearStallEPOut(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB OUT endpoint.
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+### func (*USBDevice) SetStallEPIn
+
+```go
+func (dev *USBDevice) SetStallEPIn(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB IN endpoint.
+
+
+### func (*USBDevice) SetStallEPOut
+
+```go
+func (dev *USBDevice) SetStallEPOut(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB OUT endpoint.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/pinetime-devkit0.md b/content/docs/reference/microcontrollers/machine/pinetime-devkit0.md
new file mode 100644
index 00000000..6970380c
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/pinetime-devkit0.md
@@ -0,0 +1,1086 @@
+
+---
+title: pinetime-devkit0
+---
+
+
+## Constants
+
+```go
+const HasLowFrequencyCrystal = true
+```
+
+The PineTime has a low-frequency (32kHz) crystal oscillator on board.
+
+
+```go
+const (
+	LED1	= LCD_BACKLIGHT_HIGH
+	LED2	= LCD_BACKLIGHT_MID
+	LED3	= LCD_BACKLIGHT_LOW
+	LED	= LED1
+)
+```
+
+LEDs simply expose the three brightness level LEDs on the PineTime. They can
+be useful for simple "hello world" style programs.
+
+
+```go
+const (
+	UART_TX_PIN	Pin	= 11	// TP29 (TXD)
+	UART_RX_PIN	Pin	= NoPin
+)
+```
+
+UART pins for PineTime. Note that RX is set to NoPin as RXD is not listed in
+the PineTime schematic 1.0:
+http://files.pine64.org/doc/PineTime/PineTime%20Port%20Assignment%20rev1.0.pdf
+
+
+```go
+const (
+	SPI0_SCK_PIN	Pin	= 2
+	SPI0_SDO_PIN	Pin	= 3
+	SPI0_SDI_PIN	Pin	= 4
+)
+```
+
+SPI pins for the PineTime.
+
+
+```go
+const (
+	SDA_PIN	Pin	= 6
+	SCL_PIN	Pin	= 7
+)
+```
+
+I2C pins for the PineTime.
+
+
+```go
+const (
+	BUTTON_IN	Pin	= 13
+	BUTTON_OUT	Pin	= 15
+)
+```
+
+Button pins. For some reason, there are two pins for the button.
+
+
+```go
+const VIBRATOR_PIN Pin = 16
+```
+
+Pin for the vibrator.
+
+
+```go
+const (
+	LCD_SCK				= SPI0_SCK_PIN
+	LCD_SDI				= SPI0_SDO_PIN
+	LCD_RS			Pin	= 18
+	LCD_CS			Pin	= 25
+	LCD_RESET		Pin	= 26
+	LCD_BACKLIGHT_LOW	Pin	= 14
+	LCD_BACKLIGHT_MID	Pin	= 22
+	LCD_BACKLIGHT_HIGH	Pin	= 23
+)
+```
+
+LCD pins, using the naming convention of the official docs:
+http://files.pine64.org/doc/PineTime/PineTime%20Port%20Assignment%20rev1.0.pdf
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
+	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
+	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	P0_00	Pin	= 0
+	P0_01	Pin	= 1
+	P0_02	Pin	= 2
+	P0_03	Pin	= 3
+	P0_04	Pin	= 4
+	P0_05	Pin	= 5
+	P0_06	Pin	= 6
+	P0_07	Pin	= 7
+	P0_08	Pin	= 8
+	P0_09	Pin	= 9
+	P0_10	Pin	= 10
+	P0_11	Pin	= 11
+	P0_12	Pin	= 12
+	P0_13	Pin	= 13
+	P0_14	Pin	= 14
+	P0_15	Pin	= 15
+	P0_16	Pin	= 16
+	P0_17	Pin	= 17
+	P0_18	Pin	= 18
+	P0_19	Pin	= 19
+	P0_20	Pin	= 20
+	P0_21	Pin	= 21
+	P0_22	Pin	= 22
+	P0_23	Pin	= 23
+	P0_24	Pin	= 24
+	P0_25	Pin	= 25
+	P0_26	Pin	= 26
+	P0_27	Pin	= 27
+	P0_28	Pin	= 28
+	P0_29	Pin	= 29
+	P0_30	Pin	= 30
+	P0_31	Pin	= 31
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	// UART0 is the hardware UART on the NRF SoC.
+	_UART0	= UART{Buffer: NewRingBuffer()}
+	UART0	= &_UART0
+)
+```
+
+UART
+
+
+```go
+var (
+	I2C0	= (*I2C)(unsafe.Pointer(nrf.TWI0))
+	I2C1	= (*I2C)(unsafe.Pointer(nrf.TWI1))
+)
+```
+
+There are 2 I2C interfaces on the NRF.
+
+
+```go
+var (
+	PWM0	= &PWM{PWM: nrf.PWM0}
+	PWM1	= &PWM{PWM: nrf.PWM1}
+	PWM2	= &PWM{PWM: nrf.PWM2}
+)
+```
+
+PWM
+
+
+```go
+var (
+	SPI0	= SPI{Bus: nrf.SPIM0, buf: new([1]byte)}
+	SPI1	= SPI{Bus: nrf.SPIM1, buf: new([1]byte)}
+	SPI2	= SPI{Bus: nrf.SPIM2, buf: new([1]byte)}
+)
+```
+
+There are 3 SPI interfaces on the NRF528xx.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func GetRNG
+
+```go
+func GetRNG() (ret uint32, err error)
+```
+
+GetRNG returns 32 bits of non-deterministic random data based on internal thermal noise.
+According to Nordic's documentation, the random output is suitable for cryptographic purposes.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() int32
+```
+
+ReadTemperature reads the silicon die temperature of the chip. The return
+value is in milli-celsius.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(ADCConfig)
+```
+
+Configure configures an ADC pin to be able to read analog data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus nrf.TWI_Type
+}
+```
+
+I2C on the NRF.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) (err error)
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWM
+
+```go
+type PWM struct {
+	PWM	*nrf.PWM_Type
+
+	channelValues	[4]volatile.Register16
+}
+```
+
+PWM is one PWM peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this PWM peripheral at
+once.
+
+
+
+### func (*PWM) Channel
+
+```go
+func (pwm *PWM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*PWM) Configure
+
+```go
+func (pwm *PWM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+On the nRF52 series, the maximum period is around 0.26s.
+
+
+### func (*PWM) Set
+
+```go
+func (pwm *PWM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	ch.Set(ch.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*PWM) SetInverting
+
+```go
+func (pwm *PWM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*PWM) SetPeriod
+
+```go
+func (pwm *PWM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*PWM) Top
+
+```go
+func (pwm *PWM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*nrf.SPIM_Type
+	buf	*[1]byte	// 1-byte buffer for the Transfer method
+}
+```
+
+SPI on the NRF.
+
+
+
+### func (SPI) Configure
+
+```go
+func (spi SPI) Configure(config SPIConfig)
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (SPI) Transfer
+
+```go
+func (spi SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (SPI) Tx
+
+```go
+func (spi SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous
+write/read interface, there must always be the same number of bytes written
+as bytes read. Therefore, if the number of bytes don't match it will be
+padded until they fit: if len(w) > len(r) the extra bytes received will be
+dropped and if len(w) < len(r) extra 0 bytes will be sent.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer *RingBuffer
+}
+```
+
+UART on the NRF.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data to the UART.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data to the UART.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/pybadge.md b/content/docs/reference/microcontrollers/machine/pybadge.md
new file mode 100644
index 00000000..21d01b80
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/pybadge.md
@@ -0,0 +1,1760 @@
+
+---
+title: pybadge
+---
+
+
+## Constants
+
+```go
+const (
+	D0	= PB17	// UART0 RX/PWM available
+	D1	= PB16	// UART0 TX/PWM available
+	D2	= PB03
+	D3	= PB02
+	D4	= PA14	// PWM available
+	D5	= PA16	// PWM available
+	D6	= PA18	// PWM available
+	D7	= PB14
+	D8	= PA15	// built-in neopixel
+	D9	= PA19	// PWM available
+	D10	= PA20	// can be used for PWM or UART1 TX
+	D11	= PA21	// can be used for PWM or UART1 RX
+	D12	= PA22	// PWM available
+	D13	= PA23	// PWM available
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A0	= PA02	// ADC/AIN[0]
+	A1	= PA05	// ADC/AIN[2]
+	A2	= PB08	// ADC/AIN[3]
+	A3	= PB09	// ADC/AIN[4]
+	A4	= PA04	// ADC/AIN[5]
+	A5	= PA06	// ADC/AIN[6]
+	A6	= PB01	// ADC/AIN[12]/VMEAS
+	A7	= PB04	// ADC/AIN[6]/LIGHT
+	A8	= D2	// ADC/AIN[14]
+	A9	= D3	// ADC/AIN[15]
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	LED		= D13
+	NEOPIXELS	= D8
+	WS2812		= D8
+
+	LIGHTSENSOR	= A7
+
+	BUTTON_LATCH	= PB00
+	BUTTON_OUT	= PB30
+	BUTTON_CLK	= PB31
+
+	TFT_DC		= PB05
+	TFT_CS		= PB07
+	TFT_RST		= PA00
+	TFT_LITE	= PA01
+
+	SPEAKER_ENABLE	= PA27
+)
+```
+
+
+
+```go
+const (
+	BUTTON_LEFT_MASK	= 1
+	BUTTON_UP_MASK		= 2
+	BUTTON_DOWN_MASK	= 4
+	BUTTON_RIGHT_MASK	= 8
+	BUTTON_SELECT_MASK	= 16
+	BUTTON_START_MASK	= 32
+	BUTTON_A_MASK		= 64
+	BUTTON_B_MASK		= 128
+)
+```
+
+
+
+```go
+const (
+	USBCDC_DM_PIN	= PA24
+	USBCDC_DP_PIN	= PA25
+)
+```
+
+USBCDC pins
+
+
+```go
+const (
+	UART_TX_PIN	= D1
+	UART_RX_PIN	= D0
+)
+```
+
+UART1 pins
+
+
+```go
+const (
+	UART2_TX_PIN	= A4
+	UART2_RX_PIN	= A5
+)
+```
+
+
+
+```go
+const (
+	SDA_PIN	= PA12	// SDA: SERCOM2/PAD[0]
+	SCL_PIN	= PA13	// SCL: SERCOM2/PAD[1]
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= PA17	// SCK: SERCOM1/PAD[1]
+	SPI0_SDO_PIN	= PB23	// SDO: SERCOM1/PAD[3]
+	SPI0_SDI_PIN	= PB22	// SDI: SERCOM1/PAD[2]
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	SPI1_SCK_PIN	= PB13	// SCK: SERCOM4/PAD[1]
+	SPI1_SDO_PIN	= PB15	// SDO: SERCOM4/PAD[3]
+	SPI1_SDI_PIN	= NoPin
+)
+```
+
+TFT SPI pins
+
+
+```go
+const (
+	NINA_BAUDRATE		= 115200
+	NINA_RESET_INVERTED	= true
+	NINA_SOFT_FLOWCONTROL	= true
+)
+```
+
+NINA-W102 settings when using AirLift WiFi FeatherWing
+
+
+```go
+const (
+	NINA_CS		= D13
+	NINA_ACK	= D11
+	NINA_GPIO0	= D10
+	NINA_RESETN	= D12
+
+	// pins used for the ESP32 connection do not allow hardware
+	// flow control, which is required. have to emulate with software.
+	NINA_TX		= UART_TX_PIN
+	NINA_RX		= UART_RX_PIN
+	NINA_CTS	= NINA_ACK
+	NINA_RTS	= NINA_GPIO0
+
+	NINA_SDO	= SPI0_SDO_PIN
+	NINA_SDI	= SPI0_SDI_PIN
+	NINA_SCK	= SPI0_SCK_PIN
+)
+```
+
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinAnalog		PinMode	= 1
+	PinSERCOM		PinMode	= 2
+	PinSERCOMAlt		PinMode	= 3
+	PinTimer		PinMode	= 4
+	PinTimerAlt		PinMode	= 5
+	PinTCCPDEC		PinMode	= 6
+	PinCom			PinMode	= 7
+	PinSDHC			PinMode	= 8
+	PinI2S			PinMode	= 9
+	PinPCC			PinMode	= 10
+	PinGMAC			PinMode	= 11
+	PinACCLK		PinMode	= 12
+	PinCCL			PinMode	= 13
+	PinDigital		PinMode	= 14
+	PinInput		PinMode	= 15
+	PinInputPullup		PinMode	= 16
+	PinOutput		PinMode	= 17
+	PinTCCE			PinMode	= PinTimer
+	PinTCCF			PinMode	= PinTimerAlt
+	PinTCCG			PinMode	= PinTCCPDEC
+	PinInputPulldown	PinMode	= 18
+	PinCAN			PinMode	= 19
+	PinCAN0			PinMode	= PinSDHC
+	PinCAN1			PinMode	= PinCom
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
+	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
+	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	PA00	Pin	= 0
+	PA01	Pin	= 1
+	PA02	Pin	= 2
+	PA03	Pin	= 3
+	PA04	Pin	= 4
+	PA05	Pin	= 5
+	PA06	Pin	= 6
+	PA07	Pin	= 7
+	PA08	Pin	= 8	// peripherals: TCC0 channel 0, TCC1 channel 4, sercomI2CM0 SDA, sercomI2CM2 SDA
+	PA09	Pin	= 9	// peripherals: TCC0 channel 1, TCC1 channel 5, sercomI2CM0 SCL, sercomI2CM2 SCL
+	PA10	Pin	= 10	// peripherals: TCC0 channel 2, TCC1 channel 6
+	PA11	Pin	= 11	// peripherals: TCC0 channel 3, TCC1 channel 7
+	PA12	Pin	= 12	// peripherals: TCC0 channel 6, TCC1 channel 2, sercomI2CM2 SDA, sercomI2CM4 SDA
+	PA13	Pin	= 13	// peripherals: TCC0 channel 7, TCC1 channel 3, sercomI2CM2 SCL, sercomI2CM4 SCL
+	PA14	Pin	= 14	// peripherals: TCC2 channel 0, TCC1 channel 2
+	PA15	Pin	= 15	// peripherals: TCC2 channel 1, TCC1 channel 3
+	PA16	Pin	= 16	// peripherals: TCC1 channel 0, TCC0 channel 4, sercomI2CM1 SDA, sercomI2CM3 SDA
+	PA17	Pin	= 17	// peripherals: TCC1 channel 1, TCC0 channel 5, sercomI2CM1 SCL, sercomI2CM3 SCL
+	PA18	Pin	= 18	// peripherals: TCC1 channel 2, TCC0 channel 6
+	PA19	Pin	= 19	// peripherals: TCC1 channel 3, TCC0 channel 7
+	PA20	Pin	= 20	// peripherals: TCC1 channel 4, TCC0 channel 0
+	PA21	Pin	= 21	// peripherals: TCC1 channel 5, TCC0 channel 1
+	PA22	Pin	= 22	// peripherals: TCC1 channel 6, TCC0 channel 2, sercomI2CM3 SDA, sercomI2CM5 SDA
+	PA23	Pin	= 23	// peripherals: TCC1 channel 7, TCC0 channel 3, sercomI2CM3 SCL, sercomI2CM5 SCL
+	PA24	Pin	= 24	// peripherals: TCC2 channel 2
+	PA25	Pin	= 25	// peripherals: TCC2 channel 3
+	PA26	Pin	= 26
+	PA27	Pin	= 27
+	PA28	Pin	= 28
+	PA29	Pin	= 29
+	PA30	Pin	= 30	// peripherals: TCC2 channel 0
+	PA31	Pin	= 31	// peripherals: TCC2 channel 1
+	PB00	Pin	= 32
+	PB01	Pin	= 33
+	PB02	Pin	= 34	// peripherals: TCC2 channel 2
+	PB03	Pin	= 35	// peripherals: TCC2 channel 3
+	PB04	Pin	= 36
+	PB05	Pin	= 37
+	PB06	Pin	= 38
+	PB07	Pin	= 39
+	PB08	Pin	= 40
+	PB09	Pin	= 41
+	PB10	Pin	= 42	// peripherals: TCC0 channel 4, TCC1 channel 0
+	PB11	Pin	= 43	// peripherals: TCC0 channel 5, TCC1 channel 1
+	PB12	Pin	= 44	// peripherals: TCC3 channel 0, TCC0 channel 0
+	PB13	Pin	= 45	// peripherals: TCC3 channel 1, TCC0 channel 1
+	PB14	Pin	= 46	// peripherals: TCC4 channel 0, TCC0 channel 2
+	PB15	Pin	= 47	// peripherals: TCC4 channel 1, TCC0 channel 3
+	PB16	Pin	= 48	// peripherals: TCC3 channel 0, TCC0 channel 4
+	PB17	Pin	= 49	// peripherals: TCC3 channel 1, TCC0 channel 5
+	PB18	Pin	= 50	// peripherals: TCC1 channel 0
+	PB19	Pin	= 51	// peripherals: TCC1 channel 1
+	PB20	Pin	= 52	// peripherals: TCC1 channel 2
+	PB21	Pin	= 53	// peripherals: TCC1 channel 3
+	PB22	Pin	= 54
+	PB23	Pin	= 55
+	PB24	Pin	= 56
+	PB25	Pin	= 57
+	PB26	Pin	= 58	// peripherals: TCC1 channel 2
+	PB27	Pin	= 59	// peripherals: TCC1 channel 3
+	PB28	Pin	= 60	// peripherals: TCC1 channel 4
+	PB29	Pin	= 61	// peripherals: TCC1 channel 5
+	PB30	Pin	= 62	// peripherals: TCC4 channel 0, TCC0 channel 6
+	PB31	Pin	= 63	// peripherals: TCC4 channel 1, TCC0 channel 7
+	PC00	Pin	= 64
+	PC01	Pin	= 65
+	PC02	Pin	= 66
+	PC03	Pin	= 67
+	PC04	Pin	= 68	// peripherals: TCC0 channel 0
+	PC05	Pin	= 69	// peripherals: TCC0 channel 1
+	PC06	Pin	= 70
+	PC07	Pin	= 71
+	PC08	Pin	= 72
+	PC09	Pin	= 73
+	PC10	Pin	= 74	// peripherals: TCC0 channel 0, TCC1 channel 4
+	PC11	Pin	= 75	// peripherals: TCC0 channel 1, TCC1 channel 5
+	PC12	Pin	= 76	// peripherals: TCC0 channel 2, TCC1 channel 6
+	PC13	Pin	= 77	// peripherals: TCC0 channel 3, TCC1 channel 7
+	PC14	Pin	= 78	// peripherals: TCC0 channel 4, TCC1 channel 0
+	PC15	Pin	= 79	// peripherals: TCC0 channel 5, TCC1 channel 1
+	PC16	Pin	= 80	// peripherals: TCC0 channel 0
+	PC17	Pin	= 81	// peripherals: TCC0 channel 1
+	PC18	Pin	= 82	// peripherals: TCC0 channel 2
+	PC19	Pin	= 83	// peripherals: TCC0 channel 3
+	PC20	Pin	= 84	// peripherals: TCC0 channel 4
+	PC21	Pin	= 85	// peripherals: TCC0 channel 5
+	PC22	Pin	= 86	// peripherals: TCC0 channel 6
+	PC23	Pin	= 87	// peripherals: TCC0 channel 7
+	PC24	Pin	= 88
+	PC25	Pin	= 89
+	PC26	Pin	= 90
+	PC27	Pin	= 91
+	PC28	Pin	= 92
+	PC29	Pin	= 93
+	PC30	Pin	= 94
+	PC31	Pin	= 95
+	PD00	Pin	= 96
+	PD01	Pin	= 97
+	PD02	Pin	= 98
+	PD03	Pin	= 99
+	PD04	Pin	= 100
+	PD05	Pin	= 101
+	PD06	Pin	= 102
+	PD07	Pin	= 103
+	PD08	Pin	= 104	// peripherals: TCC0 channel 1, sercomI2CM6 SDA, sercomI2CM7 SDA
+	PD09	Pin	= 105	// peripherals: TCC0 channel 2, sercomI2CM6 SCL, sercomI2CM7 SCL
+	PD10	Pin	= 106	// peripherals: TCC0 channel 3
+	PD11	Pin	= 107	// peripherals: TCC0 channel 4
+	PD12	Pin	= 108	// peripherals: TCC0 channel 5
+	PD13	Pin	= 109	// peripherals: TCC0 channel 6
+	PD14	Pin	= 110
+	PD15	Pin	= 111
+	PD16	Pin	= 112
+	PD17	Pin	= 113
+	PD18	Pin	= 114
+	PD19	Pin	= 115
+	PD20	Pin	= 116	// peripherals: TCC1 channel 0
+	PD21	Pin	= 117	// peripherals: TCC1 channel 1
+	PD22	Pin	= 118
+	PD23	Pin	= 119
+	PD24	Pin	= 120
+	PD25	Pin	= 121
+	PD26	Pin	= 122
+	PD27	Pin	= 123
+	PD28	Pin	= 124
+	PD29	Pin	= 125
+	PD30	Pin	= 126
+	PD31	Pin	= 127
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	// SERCOM_FREQ_REF is always reference frequency on SAMD51 regardless of CPU speed.
+	SERCOM_FREQ_REF		= 48000000
+	SERCOM_FREQ_REF_GCLK0	= 120000000
+
+	// Default rise time in nanoseconds, based on 4.7K ohm pull up resistors
+	riseTimeNanoseconds	= 125
+
+	// wire bus states
+	wireUnknownState	= 0
+	wireIdleState		= 1
+	wireOwnerState		= 2
+	wireBusyState		= 3
+
+	// wire commands
+	wireCmdNoAction		= 0
+	wireCmdRepeatStart	= 1
+	wireCmdRead		= 2
+	wireCmdStop		= 3
+)
+```
+
+
+
+```go
+const (
+	QSPI_SCK	= PB10
+	QSPI_CS		= PB11
+	QSPI_DATA0	= PA08
+	QSPI_DATA1	= PA09
+	QSPI_DATA2	= PA10
+	QSPI_DATA3	= PA11
+)
+```
+
+The QSPI peripheral on ATSAMD51 is only available on the following pins
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (16s)
+	WatchdogMaxTimeout = (16384 * 1000) / 1024	// CYC16384/1024kHz
+)
+```
+
+
+
+```go
+const (
+	// these are SAMD51 specific.
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Pos	= 0
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Mask	= 0x3FFF
+
+	usb_DEVICE_PCKSIZE_SIZE_Pos	= 28
+	usb_DEVICE_PCKSIZE_SIZE_Mask	= 0x7
+
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Pos	= 14
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Mask	= 0x3FFF
+
+	NumberOfUSBEndpoints	= 8
+)
+```
+
+
+
+```go
+const HSRAM_SIZE = 0x00030000
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	UART1	= &sercomUSART5
+	UART2	= &sercomUSART0
+
+	DefaultUART	= UART1
+)
+```
+
+
+
+```go
+var I2C0 = sercomI2CM2
+```
+
+I2C on the ItsyBitsy M4.
+
+
+```go
+var SPI0 = sercomSPIM1
+```
+
+SPI on the PyBadge.
+
+
+```go
+var SPI1 = sercomSPIM4
+```
+
+TFT SPI on the PyBadge.
+
+
+```go
+var (
+	NINA_SPI	= SPI0
+	UART_NINA	= UART1
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	DAC0	= DAC{Channel: 0}
+	DAC1	= DAC{Channel: 1}
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the SAMD51.
+
+
+```go
+var (
+	TCC0	= (*TCC)(sam.TCC0)
+	TCC1	= (*TCC)(sam.TCC1)
+	TCC2	= (*TCC)(sam.TCC2)
+	TCC3	= (*TCC)(sam.TCC3)
+	TCC4	= (*TCC)(sam.TCC4)
+)
+```
+
+This chip has five TCC peripherals, which have PWM as one feature.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) and 16 bytes (128 bits) are common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of cryptographically secure random data
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig)
+```
+
+Configure configures a ADCPin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type DAC
+
+```go
+type DAC struct {
+	Channel uint8
+}
+```
+
+DAC on the SAMD51.
+
+
+
+### func (DAC) Configure
+
+```go
+func (dac DAC) Configure(config DACConfig)
+```
+
+Configure the DAC.
+output pin must already be configured.
+
+
+### func (DAC) Set
+
+```go
+func (dac DAC) Set(value uint16) error
+```
+
+Set writes a single 16-bit value to the DAC.
+Since the ATSAMD51 only has a 12-bit DAC, the passed-in value will be scaled down.
+
+
+
+
+## type DACConfig
+
+```go
+type DACConfig struct {
+}
+```
+
+DACConfig placeholder for future expansion.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*sam.SERCOM_I2CM_Type
+	SERCOM	uint8
+}
+```
+
+I2C on the SAMD51.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteByte
+
+```go
+func (i2c *I2C) WriteByte(data byte) error
+```
+
+WriteByte writes a single byte to the I2C bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when configured as an input or as
+an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+### func (Pin) Toggle
+
+```go
+func (p Pin) Toggle()
+```
+
+Toggle switches an output pin from low to high or from high to low.
+Warning: only use this on an output pin!
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*sam.SERCOM_SPIM_Type
+	SERCOM	uint8
+}
+```
+
+SPI
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type TCC
+
+```go
+type TCC sam.TCC_Type
+```
+
+TCC is one timer peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this timer peripheral at
+once.
+
+
+
+### func (*TCC) Channel
+
+```go
+func (tcc *TCC) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin. Note that one channel may be
+shared between multiple pins, and so will have the same duty cycle. If this
+is not desirable, look for a different TCC or consider using a different pin.
+
+
+### func (*TCC) Configure
+
+```go
+func (tcc *TCC) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this TCC.
+
+
+### func (*TCC) Counter
+
+```go
+func (tcc *TCC) Counter() uint32
+```
+
+Counter returns the current counter value of the timer in this TCC
+peripheral. It may be useful for debugging.
+
+
+### func (*TCC) Set
+
+```go
+func (tcc *TCC) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle, in other words the fraction of time the channel output is high (or low
+when inverted). For example, to set it to a 25% duty cycle, use:
+
+	tcc.Set(channel, tcc.Top() / 4)
+
+tcc.Set(channel, 0) will set the output to low and tcc.Set(channel,
+tcc.Top()) will set the output to high, assuming the output isn't inverted.
+
+
+### func (*TCC) SetInverting
+
+```go
+func (tcc *TCC) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TCC) SetPeriod
+
+```go
+func (tcc *TCC) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this TCC peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the TCC peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TCC) Top
+
+```go
+func (tcc *TCC) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+tcc.Set (see tcc.Set for more information).
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*sam.SERCOM_USART_INT_Type
+	SERCOM		uint8
+	Interrupt	interrupt.Interrupt	// RXC interrupt
+}
+```
+
+UART on the SAMD51.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/pygamer.md b/content/docs/reference/microcontrollers/machine/pygamer.md
new file mode 100644
index 00000000..b2283798
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/pygamer.md
@@ -0,0 +1,1711 @@
+
+---
+title: pygamer
+---
+
+
+## Constants
+
+```go
+const (
+	D0	= PB17	// UART0 RX/PWM available
+	D1	= PB16	// UART0 TX/PWM available
+	D2	= PB03
+	D3	= PB02
+	D4	= PA14	// PWM available
+	D5	= PA16	// PWM available
+	D6	= PA18	// PWM available
+	D7	= PB14	// CS for microSD card slot
+	D8	= PA15	// built-in neopixel
+	D9	= PA19	// PWM available
+	D10	= PA20	// can be used for PWM or UART1 TX
+	D11	= PA21	// can be used for PWM or UART1 RX
+	D12	= PA22	// PWM available
+	D13	= PA23	// PWM available
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A0	= PA02	// ADC/AIN[0]
+	A1	= PA05	// ADC/AIN[2]
+	A2	= PB08	// ADC/AIN[3]
+	A3	= PB09	// ADC/AIN[4]
+	A4	= PA04	// ADC/AIN[5]
+	A5	= PA06	// ADC/AIN[6]
+	A6	= PB01	// ADC/AIN[12]/VMEAS
+	A7	= PB04	// ADC/AIN[6]/LIGHT
+	A8	= D2	// ADC/AIN[14]
+	A9	= D3	// ADC/AIN[15]
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	LED		= D13
+	NEOPIXELS	= D8
+	WS2812		= D8
+
+	SD_CS	= D7
+
+	LIGHTSENSOR	= A7
+
+	BUTTON_LATCH	= PB00
+	BUTTON_OUT	= PB30
+	BUTTON_CLK	= PB31
+
+	JOYY	= PB06
+	JOYX	= PB07
+
+	TFT_DC		= PB05
+	TFT_CS		= PB12
+	TFT_RST		= PA00
+	TFT_LITE	= PA01
+
+	SPEAKER_ENABLE	= PA27
+)
+```
+
+
+
+```go
+const (
+	BUTTON_SELECT_MASK	= 16
+	BUTTON_START_MASK	= 32
+	BUTTON_A_MASK		= 64
+	BUTTON_B_MASK		= 128
+)
+```
+
+
+
+```go
+const (
+	USBCDC_DM_PIN	= PA24
+	USBCDC_DP_PIN	= PA25
+)
+```
+
+USBCDC pins
+
+
+```go
+const (
+	UART_TX_PIN	= D1
+	UART_RX_PIN	= D0
+)
+```
+
+UART1 pins
+
+
+```go
+const (
+	UART2_TX_PIN	= A4
+	UART2_RX_PIN	= A5
+)
+```
+
+UART2 pins
+
+
+```go
+const (
+	SDA_PIN	= PA12	// SDA: SERCOM2/PAD[0]
+	SCL_PIN	= PA13	// SCL: SERCOM2/PAD[1]
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= PA17	// SCK: SERCOM1/PAD[1]
+	SPI0_SDO_PIN	= PB23	// SDO: SERCOM1/PAD[3]
+	SPI0_SDI_PIN	= PB22	// SDI: SERCOM1/PAD[2]
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	SPI1_SCK_PIN	= PB13	// SCK: SERCOM4/PAD[1]
+	SPI1_SDO_PIN	= PB15	// SDO: SERCOM4/PAD[3]
+	SPI1_SDI_PIN	= NoPin
+)
+```
+
+TFT SPI pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinAnalog		PinMode	= 1
+	PinSERCOM		PinMode	= 2
+	PinSERCOMAlt		PinMode	= 3
+	PinTimer		PinMode	= 4
+	PinTimerAlt		PinMode	= 5
+	PinTCCPDEC		PinMode	= 6
+	PinCom			PinMode	= 7
+	PinSDHC			PinMode	= 8
+	PinI2S			PinMode	= 9
+	PinPCC			PinMode	= 10
+	PinGMAC			PinMode	= 11
+	PinACCLK		PinMode	= 12
+	PinCCL			PinMode	= 13
+	PinDigital		PinMode	= 14
+	PinInput		PinMode	= 15
+	PinInputPullup		PinMode	= 16
+	PinOutput		PinMode	= 17
+	PinTCCE			PinMode	= PinTimer
+	PinTCCF			PinMode	= PinTimerAlt
+	PinTCCG			PinMode	= PinTCCPDEC
+	PinInputPulldown	PinMode	= 18
+	PinCAN			PinMode	= 19
+	PinCAN0			PinMode	= PinSDHC
+	PinCAN1			PinMode	= PinCom
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
+	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
+	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	PA00	Pin	= 0
+	PA01	Pin	= 1
+	PA02	Pin	= 2
+	PA03	Pin	= 3
+	PA04	Pin	= 4
+	PA05	Pin	= 5
+	PA06	Pin	= 6
+	PA07	Pin	= 7
+	PA08	Pin	= 8	// peripherals: TCC0 channel 0, TCC1 channel 4, sercomI2CM0 SDA, sercomI2CM2 SDA
+	PA09	Pin	= 9	// peripherals: TCC0 channel 1, TCC1 channel 5, sercomI2CM0 SCL, sercomI2CM2 SCL
+	PA10	Pin	= 10	// peripherals: TCC0 channel 2, TCC1 channel 6
+	PA11	Pin	= 11	// peripherals: TCC0 channel 3, TCC1 channel 7
+	PA12	Pin	= 12	// peripherals: TCC0 channel 6, TCC1 channel 2, sercomI2CM2 SDA, sercomI2CM4 SDA
+	PA13	Pin	= 13	// peripherals: TCC0 channel 7, TCC1 channel 3, sercomI2CM2 SCL, sercomI2CM4 SCL
+	PA14	Pin	= 14	// peripherals: TCC2 channel 0, TCC1 channel 2
+	PA15	Pin	= 15	// peripherals: TCC2 channel 1, TCC1 channel 3
+	PA16	Pin	= 16	// peripherals: TCC1 channel 0, TCC0 channel 4, sercomI2CM1 SDA, sercomI2CM3 SDA
+	PA17	Pin	= 17	// peripherals: TCC1 channel 1, TCC0 channel 5, sercomI2CM1 SCL, sercomI2CM3 SCL
+	PA18	Pin	= 18	// peripherals: TCC1 channel 2, TCC0 channel 6
+	PA19	Pin	= 19	// peripherals: TCC1 channel 3, TCC0 channel 7
+	PA20	Pin	= 20	// peripherals: TCC1 channel 4, TCC0 channel 0
+	PA21	Pin	= 21	// peripherals: TCC1 channel 5, TCC0 channel 1
+	PA22	Pin	= 22	// peripherals: TCC1 channel 6, TCC0 channel 2, sercomI2CM3 SDA, sercomI2CM5 SDA
+	PA23	Pin	= 23	// peripherals: TCC1 channel 7, TCC0 channel 3, sercomI2CM3 SCL, sercomI2CM5 SCL
+	PA24	Pin	= 24	// peripherals: TCC2 channel 2
+	PA25	Pin	= 25	// peripherals: TCC2 channel 3
+	PA26	Pin	= 26
+	PA27	Pin	= 27
+	PA28	Pin	= 28
+	PA29	Pin	= 29
+	PA30	Pin	= 30	// peripherals: TCC2 channel 0
+	PA31	Pin	= 31	// peripherals: TCC2 channel 1
+	PB00	Pin	= 32
+	PB01	Pin	= 33
+	PB02	Pin	= 34	// peripherals: TCC2 channel 2
+	PB03	Pin	= 35	// peripherals: TCC2 channel 3
+	PB04	Pin	= 36
+	PB05	Pin	= 37
+	PB06	Pin	= 38
+	PB07	Pin	= 39
+	PB08	Pin	= 40
+	PB09	Pin	= 41
+	PB10	Pin	= 42	// peripherals: TCC0 channel 4, TCC1 channel 0
+	PB11	Pin	= 43	// peripherals: TCC0 channel 5, TCC1 channel 1
+	PB12	Pin	= 44	// peripherals: TCC3 channel 0, TCC0 channel 0
+	PB13	Pin	= 45	// peripherals: TCC3 channel 1, TCC0 channel 1
+	PB14	Pin	= 46	// peripherals: TCC4 channel 0, TCC0 channel 2
+	PB15	Pin	= 47	// peripherals: TCC4 channel 1, TCC0 channel 3
+	PB16	Pin	= 48	// peripherals: TCC3 channel 0, TCC0 channel 4
+	PB17	Pin	= 49	// peripherals: TCC3 channel 1, TCC0 channel 5
+	PB18	Pin	= 50	// peripherals: TCC1 channel 0
+	PB19	Pin	= 51	// peripherals: TCC1 channel 1
+	PB20	Pin	= 52	// peripherals: TCC1 channel 2
+	PB21	Pin	= 53	// peripherals: TCC1 channel 3
+	PB22	Pin	= 54
+	PB23	Pin	= 55
+	PB24	Pin	= 56
+	PB25	Pin	= 57
+	PB26	Pin	= 58	// peripherals: TCC1 channel 2
+	PB27	Pin	= 59	// peripherals: TCC1 channel 3
+	PB28	Pin	= 60	// peripherals: TCC1 channel 4
+	PB29	Pin	= 61	// peripherals: TCC1 channel 5
+	PB30	Pin	= 62	// peripherals: TCC4 channel 0, TCC0 channel 6
+	PB31	Pin	= 63	// peripherals: TCC4 channel 1, TCC0 channel 7
+	PC00	Pin	= 64
+	PC01	Pin	= 65
+	PC02	Pin	= 66
+	PC03	Pin	= 67
+	PC04	Pin	= 68	// peripherals: TCC0 channel 0
+	PC05	Pin	= 69	// peripherals: TCC0 channel 1
+	PC06	Pin	= 70
+	PC07	Pin	= 71
+	PC08	Pin	= 72
+	PC09	Pin	= 73
+	PC10	Pin	= 74	// peripherals: TCC0 channel 0, TCC1 channel 4
+	PC11	Pin	= 75	// peripherals: TCC0 channel 1, TCC1 channel 5
+	PC12	Pin	= 76	// peripherals: TCC0 channel 2, TCC1 channel 6
+	PC13	Pin	= 77	// peripherals: TCC0 channel 3, TCC1 channel 7
+	PC14	Pin	= 78	// peripherals: TCC0 channel 4, TCC1 channel 0
+	PC15	Pin	= 79	// peripherals: TCC0 channel 5, TCC1 channel 1
+	PC16	Pin	= 80	// peripherals: TCC0 channel 0
+	PC17	Pin	= 81	// peripherals: TCC0 channel 1
+	PC18	Pin	= 82	// peripherals: TCC0 channel 2
+	PC19	Pin	= 83	// peripherals: TCC0 channel 3
+	PC20	Pin	= 84	// peripherals: TCC0 channel 4
+	PC21	Pin	= 85	// peripherals: TCC0 channel 5
+	PC22	Pin	= 86	// peripherals: TCC0 channel 6
+	PC23	Pin	= 87	// peripherals: TCC0 channel 7
+	PC24	Pin	= 88
+	PC25	Pin	= 89
+	PC26	Pin	= 90
+	PC27	Pin	= 91
+	PC28	Pin	= 92
+	PC29	Pin	= 93
+	PC30	Pin	= 94
+	PC31	Pin	= 95
+	PD00	Pin	= 96
+	PD01	Pin	= 97
+	PD02	Pin	= 98
+	PD03	Pin	= 99
+	PD04	Pin	= 100
+	PD05	Pin	= 101
+	PD06	Pin	= 102
+	PD07	Pin	= 103
+	PD08	Pin	= 104	// peripherals: TCC0 channel 1, sercomI2CM6 SDA, sercomI2CM7 SDA
+	PD09	Pin	= 105	// peripherals: TCC0 channel 2, sercomI2CM6 SCL, sercomI2CM7 SCL
+	PD10	Pin	= 106	// peripherals: TCC0 channel 3
+	PD11	Pin	= 107	// peripherals: TCC0 channel 4
+	PD12	Pin	= 108	// peripherals: TCC0 channel 5
+	PD13	Pin	= 109	// peripherals: TCC0 channel 6
+	PD14	Pin	= 110
+	PD15	Pin	= 111
+	PD16	Pin	= 112
+	PD17	Pin	= 113
+	PD18	Pin	= 114
+	PD19	Pin	= 115
+	PD20	Pin	= 116	// peripherals: TCC1 channel 0
+	PD21	Pin	= 117	// peripherals: TCC1 channel 1
+	PD22	Pin	= 118
+	PD23	Pin	= 119
+	PD24	Pin	= 120
+	PD25	Pin	= 121
+	PD26	Pin	= 122
+	PD27	Pin	= 123
+	PD28	Pin	= 124
+	PD29	Pin	= 125
+	PD30	Pin	= 126
+	PD31	Pin	= 127
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	// SERCOM_FREQ_REF is always reference frequency on SAMD51 regardless of CPU speed.
+	SERCOM_FREQ_REF		= 48000000
+	SERCOM_FREQ_REF_GCLK0	= 120000000
+
+	// Default rise time in nanoseconds, based on 4.7K ohm pull up resistors
+	riseTimeNanoseconds	= 125
+
+	// wire bus states
+	wireUnknownState	= 0
+	wireIdleState		= 1
+	wireOwnerState		= 2
+	wireBusyState		= 3
+
+	// wire commands
+	wireCmdNoAction		= 0
+	wireCmdRepeatStart	= 1
+	wireCmdRead		= 2
+	wireCmdStop		= 3
+)
+```
+
+
+
+```go
+const (
+	QSPI_SCK	= PB10
+	QSPI_CS		= PB11
+	QSPI_DATA0	= PA08
+	QSPI_DATA1	= PA09
+	QSPI_DATA2	= PA10
+	QSPI_DATA3	= PA11
+)
+```
+
+The QSPI peripheral on ATSAMD51 is only available on the following pins
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (16s)
+	WatchdogMaxTimeout = (16384 * 1000) / 1024	// CYC16384/1024kHz
+)
+```
+
+
+
+```go
+const (
+	// these are SAMD51 specific.
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Pos	= 0
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Mask	= 0x3FFF
+
+	usb_DEVICE_PCKSIZE_SIZE_Pos	= 28
+	usb_DEVICE_PCKSIZE_SIZE_Mask	= 0x7
+
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Pos	= 14
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Mask	= 0x3FFF
+
+	NumberOfUSBEndpoints	= 8
+)
+```
+
+
+
+```go
+const HSRAM_SIZE = 0x00030000
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	I2C0 = sercomI2CM2
+)
+```
+
+I2C on the PyGamer.
+
+
+```go
+var SPI0 = sercomSPIM1
+```
+
+SPI on the PyGamer.
+
+
+```go
+var SPI1 = sercomSPIM4
+```
+
+TFT SPI on the PyGamer.
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	DAC0	= DAC{Channel: 0}
+	DAC1	= DAC{Channel: 1}
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the SAMD51.
+
+
+```go
+var (
+	TCC0	= (*TCC)(sam.TCC0)
+	TCC1	= (*TCC)(sam.TCC1)
+	TCC2	= (*TCC)(sam.TCC2)
+	TCC3	= (*TCC)(sam.TCC3)
+	TCC4	= (*TCC)(sam.TCC4)
+)
+```
+
+This chip has five TCC peripherals, which have PWM as one feature.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) and 16 bytes (128 bits) are common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of cryptographically secure random data
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig)
+```
+
+Configure configures a ADCPin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type DAC
+
+```go
+type DAC struct {
+	Channel uint8
+}
+```
+
+DAC on the SAMD51.
+
+
+
+### func (DAC) Configure
+
+```go
+func (dac DAC) Configure(config DACConfig)
+```
+
+Configure the DAC.
+output pin must already be configured.
+
+
+### func (DAC) Set
+
+```go
+func (dac DAC) Set(value uint16) error
+```
+
+Set writes a single 16-bit value to the DAC.
+Since the ATSAMD51 only has a 12-bit DAC, the passed-in value will be scaled down.
+
+
+
+
+## type DACConfig
+
+```go
+type DACConfig struct {
+}
+```
+
+DACConfig placeholder for future expansion.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*sam.SERCOM_I2CM_Type
+	SERCOM	uint8
+}
+```
+
+I2C on the SAMD51.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteByte
+
+```go
+func (i2c *I2C) WriteByte(data byte) error
+```
+
+WriteByte writes a single byte to the I2C bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when configured as an input or as
+an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+### func (Pin) Toggle
+
+```go
+func (p Pin) Toggle()
+```
+
+Toggle switches an output pin from low to high or from high to low.
+Warning: only use this on an output pin!
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*sam.SERCOM_SPIM_Type
+	SERCOM	uint8
+}
+```
+
+SPI
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type TCC
+
+```go
+type TCC sam.TCC_Type
+```
+
+TCC is one timer peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this timer peripheral at
+once.
+
+
+
+### func (*TCC) Channel
+
+```go
+func (tcc *TCC) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin. Note that one channel may be
+shared between multiple pins, and so will have the same duty cycle. If this
+is not desirable, look for a different TCC or consider using a different pin.
+
+
+### func (*TCC) Configure
+
+```go
+func (tcc *TCC) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this TCC.
+
+
+### func (*TCC) Counter
+
+```go
+func (tcc *TCC) Counter() uint32
+```
+
+Counter returns the current counter value of the timer in this TCC
+peripheral. It may be useful for debugging.
+
+
+### func (*TCC) Set
+
+```go
+func (tcc *TCC) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle, in other words the fraction of time the channel output is high (or low
+when inverted). For example, to set it to a 25% duty cycle, use:
+
+	tcc.Set(channel, tcc.Top() / 4)
+
+tcc.Set(channel, 0) will set the output to low and tcc.Set(channel,
+tcc.Top()) will set the output to high, assuming the output isn't inverted.
+
+
+### func (*TCC) SetInverting
+
+```go
+func (tcc *TCC) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TCC) SetPeriod
+
+```go
+func (tcc *TCC) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this TCC peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the TCC peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TCC) Top
+
+```go
+func (tcc *TCC) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+tcc.Set (see tcc.Set for more information).
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*sam.SERCOM_USART_INT_Type
+	SERCOM		uint8
+	Interrupt	interrupt.Interrupt	// RXC interrupt
+}
+```
+
+UART on the SAMD51.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/pyportal.md b/content/docs/reference/microcontrollers/machine/pyportal.md
new file mode 100644
index 00000000..732cc163
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/pyportal.md
@@ -0,0 +1,1739 @@
+
+---
+title: pyportal
+---
+
+
+## Constants
+
+```go
+const (
+	D0	= PB13	// NINA_RX
+	D1	= PB12	// NINA_TX
+	D2	= PB22	// built-in neopixel
+	D3	= PA04	// PWM available
+	D4	= PA05	// PWM available
+	D5	= PB16	// NINA_ACK
+	D6	= PB15	// NINA_GPIO0
+	D7	= PB17	// NINA_RESETN
+	D8	= PB14	// NINA_CS
+	D9	= PB04	// TFT_RD
+	D10	= PB05	// TFT_DC
+	D11	= PB06	// TFT_CS
+	D12	= PB07	// TFT_TE
+	D13	= PB23	// built-in LED
+	D24	= PA00	// TFT_RESET
+	D25	= PB31	// TFT_BACKLIGHT
+	D26	= PB09	// TFT_WR
+	D27	= PB02	// SDA
+	D28	= PB03	// SCL
+	D29	= PA12	// SDO
+	D30	= PA13	// SCK
+	D31	= PA14	// SDI
+	D32	= PB30	// SD_CS
+	D33	= PA01	// SD_CARD_DETECT
+	D34	= PA16	// LCD_DATA0
+	D35	= PA17	// LCD_DATA1
+	D36	= PA18	// LCD_DATA2
+	D37	= PA19	// LCD_DATA3
+	D38	= PA20	// LCD_DATA4
+	D39	= PA21	// LCD_DATA5
+	D40	= PA22	// LCD_DATA6
+	D41	= PA23	// LCD_DATA7
+	D42	= PB10	// QSPI
+	D43	= PB11	// QSPI
+	D44	= PA08	// QSPI
+	D45	= PA09	// QSPI
+	D46	= PA10	// QSPI
+	D47	= PA11	// QSPI
+	D50	= PA02	// speaker amplifier shutdown
+	D51	= PA15	// NINA_RTS
+
+	NINA_CS		= D8
+	NINA_ACK	= D5
+	NINA_GPIO0	= D6
+	NINA_RESETN	= D7
+
+	// pins used for the ESP32 connection do not allow hardware
+	// flow control, which is required. have to emulate with software.
+	NINA_TX		= D1
+	NINA_RX		= D0
+	NINA_CTS	= NINA_ACK
+	NINA_RTS	= NINA_GPIO0
+
+	LCD_DATA0	= D34
+
+	TFT_RD		= D9
+	TFT_DC		= D10
+	TFT_CS		= D11
+	TFT_TE		= D12
+	TFT_RESET	= D24
+	TFT_BACKLIGHT	= D25
+	TFT_WR		= D26
+
+	NEOPIXEL	= D2
+	WS2812		= D2
+	SPK_SD		= D50
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A0	= PA02	// ADC0/AIN[0]
+	A1	= D3	// ADC0/AIN[4]
+	A2	= PA07	// ADC0/AIN[7]
+	A3	= D4	// ADC0/AIN[5]
+	A4	= PB00	// ADC0/AIN[12]
+	A5	= PB01	// ADC0/AIN[13]
+	A6	= PA06	// ADC0/AIN[6]
+	A7	= PB08	// ADC1/AIN[0]
+
+	AUDIO_OUT	= A0
+	LIGHT		= A2
+	TOUCH_YD	= A4
+	TOUCH_XL	= A5
+	TOUCH_YU	= A6
+	TOUCH_XR	= A7
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	LED = D13
+)
+```
+
+
+
+```go
+const (
+	USBCDC_DM_PIN	= PA24
+	USBCDC_DP_PIN	= PA25
+)
+```
+
+USBCDC pins
+
+
+```go
+const (
+	UART_TX_PIN	= D1
+	UART_RX_PIN	= D0
+)
+```
+
+UART1 aka NINA_TX/NINA_RX
+
+
+```go
+const (
+	NINA_BAUDRATE		= 115200
+	NINA_RESET_INVERTED	= true
+	NINA_SOFT_FLOWCONTROL	= true
+)
+```
+
+NINA-W102 settings
+
+
+```go
+const (
+	SDA_PIN	= PB02	// SDA: SERCOM2/PAD[0]
+	SCL_PIN	= PB03	// SCL: SERCOM2/PAD[1]
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= PA13	// SCK: SERCOM1/PAD[1]
+	SPI0_SDO_PIN	= PA12	// SDO: SERCOM1/PAD[3]
+	SPI0_SDI_PIN	= PA14	// SDI: SERCOM1/PAD[2]
+
+	NINA_SDO	= SPI0_SDO_PIN
+	NINA_SDI	= SPI0_SDI_PIN
+	NINA_SCK	= SPI0_SCK_PIN
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinAnalog		PinMode	= 1
+	PinSERCOM		PinMode	= 2
+	PinSERCOMAlt		PinMode	= 3
+	PinTimer		PinMode	= 4
+	PinTimerAlt		PinMode	= 5
+	PinTCCPDEC		PinMode	= 6
+	PinCom			PinMode	= 7
+	PinSDHC			PinMode	= 8
+	PinI2S			PinMode	= 9
+	PinPCC			PinMode	= 10
+	PinGMAC			PinMode	= 11
+	PinACCLK		PinMode	= 12
+	PinCCL			PinMode	= 13
+	PinDigital		PinMode	= 14
+	PinInput		PinMode	= 15
+	PinInputPullup		PinMode	= 16
+	PinOutput		PinMode	= 17
+	PinTCCE			PinMode	= PinTimer
+	PinTCCF			PinMode	= PinTimerAlt
+	PinTCCG			PinMode	= PinTCCPDEC
+	PinInputPulldown	PinMode	= 18
+	PinCAN			PinMode	= 19
+	PinCAN0			PinMode	= PinSDHC
+	PinCAN1			PinMode	= PinCom
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
+	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
+	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	PA00	Pin	= 0
+	PA01	Pin	= 1
+	PA02	Pin	= 2
+	PA03	Pin	= 3
+	PA04	Pin	= 4
+	PA05	Pin	= 5
+	PA06	Pin	= 6
+	PA07	Pin	= 7
+	PA08	Pin	= 8	// peripherals: TCC0 channel 0, TCC1 channel 4, sercomI2CM0 SDA, sercomI2CM2 SDA
+	PA09	Pin	= 9	// peripherals: TCC0 channel 1, TCC1 channel 5, sercomI2CM0 SCL, sercomI2CM2 SCL
+	PA10	Pin	= 10	// peripherals: TCC0 channel 2, TCC1 channel 6
+	PA11	Pin	= 11	// peripherals: TCC0 channel 3, TCC1 channel 7
+	PA12	Pin	= 12	// peripherals: TCC0 channel 6, TCC1 channel 2, sercomI2CM2 SDA, sercomI2CM4 SDA
+	PA13	Pin	= 13	// peripherals: TCC0 channel 7, TCC1 channel 3, sercomI2CM2 SCL, sercomI2CM4 SCL
+	PA14	Pin	= 14	// peripherals: TCC2 channel 0, TCC1 channel 2
+	PA15	Pin	= 15	// peripherals: TCC2 channel 1, TCC1 channel 3
+	PA16	Pin	= 16	// peripherals: TCC1 channel 0, TCC0 channel 4, sercomI2CM1 SDA, sercomI2CM3 SDA
+	PA17	Pin	= 17	// peripherals: TCC1 channel 1, TCC0 channel 5, sercomI2CM1 SCL, sercomI2CM3 SCL
+	PA18	Pin	= 18	// peripherals: TCC1 channel 2, TCC0 channel 6
+	PA19	Pin	= 19	// peripherals: TCC1 channel 3, TCC0 channel 7
+	PA20	Pin	= 20	// peripherals: TCC1 channel 4, TCC0 channel 0
+	PA21	Pin	= 21	// peripherals: TCC1 channel 5, TCC0 channel 1
+	PA22	Pin	= 22	// peripherals: TCC1 channel 6, TCC0 channel 2, sercomI2CM3 SDA, sercomI2CM5 SDA
+	PA23	Pin	= 23	// peripherals: TCC1 channel 7, TCC0 channel 3, sercomI2CM3 SCL, sercomI2CM5 SCL
+	PA24	Pin	= 24	// peripherals: TCC2 channel 2
+	PA25	Pin	= 25	// peripherals: TCC2 channel 3
+	PA26	Pin	= 26
+	PA27	Pin	= 27
+	PA28	Pin	= 28
+	PA29	Pin	= 29
+	PA30	Pin	= 30	// peripherals: TCC2 channel 0
+	PA31	Pin	= 31	// peripherals: TCC2 channel 1
+	PB00	Pin	= 32
+	PB01	Pin	= 33
+	PB02	Pin	= 34	// peripherals: TCC2 channel 2
+	PB03	Pin	= 35	// peripherals: TCC2 channel 3
+	PB04	Pin	= 36
+	PB05	Pin	= 37
+	PB06	Pin	= 38
+	PB07	Pin	= 39
+	PB08	Pin	= 40
+	PB09	Pin	= 41
+	PB10	Pin	= 42	// peripherals: TCC0 channel 4, TCC1 channel 0
+	PB11	Pin	= 43	// peripherals: TCC0 channel 5, TCC1 channel 1
+	PB12	Pin	= 44	// peripherals: TCC3 channel 0, TCC0 channel 0
+	PB13	Pin	= 45	// peripherals: TCC3 channel 1, TCC0 channel 1
+	PB14	Pin	= 46	// peripherals: TCC4 channel 0, TCC0 channel 2
+	PB15	Pin	= 47	// peripherals: TCC4 channel 1, TCC0 channel 3
+	PB16	Pin	= 48	// peripherals: TCC3 channel 0, TCC0 channel 4
+	PB17	Pin	= 49	// peripherals: TCC3 channel 1, TCC0 channel 5
+	PB18	Pin	= 50	// peripherals: TCC1 channel 0
+	PB19	Pin	= 51	// peripherals: TCC1 channel 1
+	PB20	Pin	= 52	// peripherals: TCC1 channel 2
+	PB21	Pin	= 53	// peripherals: TCC1 channel 3
+	PB22	Pin	= 54
+	PB23	Pin	= 55
+	PB24	Pin	= 56
+	PB25	Pin	= 57
+	PB26	Pin	= 58	// peripherals: TCC1 channel 2
+	PB27	Pin	= 59	// peripherals: TCC1 channel 3
+	PB28	Pin	= 60	// peripherals: TCC1 channel 4
+	PB29	Pin	= 61	// peripherals: TCC1 channel 5
+	PB30	Pin	= 62	// peripherals: TCC4 channel 0, TCC0 channel 6
+	PB31	Pin	= 63	// peripherals: TCC4 channel 1, TCC0 channel 7
+	PC00	Pin	= 64
+	PC01	Pin	= 65
+	PC02	Pin	= 66
+	PC03	Pin	= 67
+	PC04	Pin	= 68	// peripherals: TCC0 channel 0
+	PC05	Pin	= 69	// peripherals: TCC0 channel 1
+	PC06	Pin	= 70
+	PC07	Pin	= 71
+	PC08	Pin	= 72
+	PC09	Pin	= 73
+	PC10	Pin	= 74	// peripherals: TCC0 channel 0, TCC1 channel 4
+	PC11	Pin	= 75	// peripherals: TCC0 channel 1, TCC1 channel 5
+	PC12	Pin	= 76	// peripherals: TCC0 channel 2, TCC1 channel 6
+	PC13	Pin	= 77	// peripherals: TCC0 channel 3, TCC1 channel 7
+	PC14	Pin	= 78	// peripherals: TCC0 channel 4, TCC1 channel 0
+	PC15	Pin	= 79	// peripherals: TCC0 channel 5, TCC1 channel 1
+	PC16	Pin	= 80	// peripherals: TCC0 channel 0
+	PC17	Pin	= 81	// peripherals: TCC0 channel 1
+	PC18	Pin	= 82	// peripherals: TCC0 channel 2
+	PC19	Pin	= 83	// peripherals: TCC0 channel 3
+	PC20	Pin	= 84	// peripherals: TCC0 channel 4
+	PC21	Pin	= 85	// peripherals: TCC0 channel 5
+	PC22	Pin	= 86	// peripherals: TCC0 channel 6
+	PC23	Pin	= 87	// peripherals: TCC0 channel 7
+	PC24	Pin	= 88
+	PC25	Pin	= 89
+	PC26	Pin	= 90
+	PC27	Pin	= 91
+	PC28	Pin	= 92
+	PC29	Pin	= 93
+	PC30	Pin	= 94
+	PC31	Pin	= 95
+	PD00	Pin	= 96
+	PD01	Pin	= 97
+	PD02	Pin	= 98
+	PD03	Pin	= 99
+	PD04	Pin	= 100
+	PD05	Pin	= 101
+	PD06	Pin	= 102
+	PD07	Pin	= 103
+	PD08	Pin	= 104	// peripherals: TCC0 channel 1, sercomI2CM6 SDA, sercomI2CM7 SDA
+	PD09	Pin	= 105	// peripherals: TCC0 channel 2, sercomI2CM6 SCL, sercomI2CM7 SCL
+	PD10	Pin	= 106	// peripherals: TCC0 channel 3
+	PD11	Pin	= 107	// peripherals: TCC0 channel 4
+	PD12	Pin	= 108	// peripherals: TCC0 channel 5
+	PD13	Pin	= 109	// peripherals: TCC0 channel 6
+	PD14	Pin	= 110
+	PD15	Pin	= 111
+	PD16	Pin	= 112
+	PD17	Pin	= 113
+	PD18	Pin	= 114
+	PD19	Pin	= 115
+	PD20	Pin	= 116	// peripherals: TCC1 channel 0
+	PD21	Pin	= 117	// peripherals: TCC1 channel 1
+	PD22	Pin	= 118
+	PD23	Pin	= 119
+	PD24	Pin	= 120
+	PD25	Pin	= 121
+	PD26	Pin	= 122
+	PD27	Pin	= 123
+	PD28	Pin	= 124
+	PD29	Pin	= 125
+	PD30	Pin	= 126
+	PD31	Pin	= 127
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	// SERCOM_FREQ_REF is always reference frequency on SAMD51 regardless of CPU speed.
+	SERCOM_FREQ_REF		= 48000000
+	SERCOM_FREQ_REF_GCLK0	= 120000000
+
+	// Default rise time in nanoseconds, based on 4.7K ohm pull up resistors
+	riseTimeNanoseconds	= 125
+
+	// wire bus states
+	wireUnknownState	= 0
+	wireIdleState		= 1
+	wireOwnerState		= 2
+	wireBusyState		= 3
+
+	// wire commands
+	wireCmdNoAction		= 0
+	wireCmdRepeatStart	= 1
+	wireCmdRead		= 2
+	wireCmdStop		= 3
+)
+```
+
+
+
+```go
+const (
+	QSPI_SCK	= PB10
+	QSPI_CS		= PB11
+	QSPI_DATA0	= PA08
+	QSPI_DATA1	= PA09
+	QSPI_DATA2	= PA10
+	QSPI_DATA3	= PA11
+)
+```
+
+The QSPI peripheral on ATSAMD51 is only available on the following pins
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (16s)
+	WatchdogMaxTimeout = (16384 * 1000) / 1024	// CYC16384/1024kHz
+)
+```
+
+
+
+```go
+const (
+	// these are SAMD51 specific.
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Pos	= 0
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Mask	= 0x3FFF
+
+	usb_DEVICE_PCKSIZE_SIZE_Pos	= 28
+	usb_DEVICE_PCKSIZE_SIZE_Mask	= 0x7
+
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Pos	= 14
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Mask	= 0x3FFF
+
+	NumberOfUSBEndpoints	= 8
+)
+```
+
+
+
+```go
+const HSRAM_SIZE = 0x00040000
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	UART1	= &sercomUSART4
+
+	DefaultUART	= UART1
+
+	UART_NINA	= UART1
+)
+```
+
+
+
+```go
+var (
+	I2C0 = sercomI2CM5
+)
+```
+
+I2C on the PyPortal.
+
+
+```go
+var (
+	SPI0		= sercomSPIM2
+	NINA_SPI	= SPI0
+)
+```
+
+SPI on the PyPortal.
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	DAC0	= DAC{Channel: 0}
+	DAC1	= DAC{Channel: 1}
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the SAMD51.
+
+
+```go
+var (
+	TCC0	= (*TCC)(sam.TCC0)
+	TCC1	= (*TCC)(sam.TCC1)
+	TCC2	= (*TCC)(sam.TCC2)
+	TCC3	= (*TCC)(sam.TCC3)
+	TCC4	= (*TCC)(sam.TCC4)
+)
+```
+
+This chip has five TCC peripherals, which have PWM as one feature.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) and 16 bytes (128 bits) are common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of cryptographically secure random data
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig)
+```
+
+Configure configures a ADCPin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type DAC
+
+```go
+type DAC struct {
+	Channel uint8
+}
+```
+
+DAC on the SAMD51.
+
+
+
+### func (DAC) Configure
+
+```go
+func (dac DAC) Configure(config DACConfig)
+```
+
+Configure the DAC.
+output pin must already be configured.
+
+
+### func (DAC) Set
+
+```go
+func (dac DAC) Set(value uint16) error
+```
+
+Set writes a single 16-bit value to the DAC.
+Since the ATSAMD51 only has a 12-bit DAC, the passed-in value will be scaled down.
+
+
+
+
+## type DACConfig
+
+```go
+type DACConfig struct {
+}
+```
+
+DACConfig placeholder for future expansion.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*sam.SERCOM_I2CM_Type
+	SERCOM	uint8
+}
+```
+
+I2C on the SAMD51.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteByte
+
+```go
+func (i2c *I2C) WriteByte(data byte) error
+```
+
+WriteByte writes a single byte to the I2C bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when configured as an input or as
+an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+### func (Pin) Toggle
+
+```go
+func (p Pin) Toggle()
+```
+
+Toggle switches an output pin from low to high or from high to low.
+Warning: only use this on an output pin!
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*sam.SERCOM_SPIM_Type
+	SERCOM	uint8
+}
+```
+
+SPI
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type TCC
+
+```go
+type TCC sam.TCC_Type
+```
+
+TCC is one timer peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this timer peripheral at
+once.
+
+
+
+### func (*TCC) Channel
+
+```go
+func (tcc *TCC) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin. Note that one channel may be
+shared between multiple pins, and so will have the same duty cycle. If this
+is not desirable, look for a different TCC or consider using a different pin.
+
+
+### func (*TCC) Configure
+
+```go
+func (tcc *TCC) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this TCC.
+
+
+### func (*TCC) Counter
+
+```go
+func (tcc *TCC) Counter() uint32
+```
+
+Counter returns the current counter value of the timer in this TCC
+peripheral. It may be useful for debugging.
+
+
+### func (*TCC) Set
+
+```go
+func (tcc *TCC) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle, in other words the fraction of time the channel output is high (or low
+when inverted). For example, to set it to a 25% duty cycle, use:
+
+	tcc.Set(channel, tcc.Top() / 4)
+
+tcc.Set(channel, 0) will set the output to low and tcc.Set(channel,
+tcc.Top()) will set the output to high, assuming the output isn't inverted.
+
+
+### func (*TCC) SetInverting
+
+```go
+func (tcc *TCC) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TCC) SetPeriod
+
+```go
+func (tcc *TCC) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this TCC peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the TCC peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TCC) Top
+
+```go
+func (tcc *TCC) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+tcc.Set (see tcc.Set for more information).
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*sam.SERCOM_USART_INT_Type
+	SERCOM		uint8
+	Interrupt	interrupt.Interrupt	// RXC interrupt
+}
+```
+
+UART on the SAMD51.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/qtpy-rp2040.md b/content/docs/reference/microcontrollers/machine/qtpy-rp2040.md
new file mode 100644
index 00000000..22909cd2
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/qtpy-rp2040.md
@@ -0,0 +1,1699 @@
+
+---
+title: qtpy-rp2040
+---
+
+
+## Constants
+
+```go
+const (
+	SDA	= GPIO24
+	SCL	= GPIO25
+	TX	= GPIO20
+	MO	= GPIO3
+	MOSI	= GPIO3
+	MI	= GPIO4
+	MISO	= GPIO4
+	SCK	= GPIO6
+	RX	= GPIO5
+
+	QT_SCL1	= GPIO23
+	QT_SDA1	= GPIO22
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A0	= GPIO29
+	A1	= GPIO28
+	A2	= GPIO27
+	A3	= GPIO26
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	NEOPIXEL	= GPIO12
+	WS2812		= GPIO12
+	NEOPIXEL_POWER	= GPIO11
+)
+```
+
+
+
+```go
+const (
+	I2C0_SDA_PIN	= GPIO24
+	I2C0_SCL_PIN	= GPIO25
+
+	I2C1_SDA_PIN	= GPIO26
+	I2C1_SCL_PIN	= GPIO27
+
+	I2C1_QT_SDA_PIN	= GPIO22
+	I2C1_QT_SCL_PIN	= GPIO23
+
+	SDA_PIN	= GPIO24
+	SCL_PIN	= GPIO25
+)
+```
+
+I2C Pins.
+
+
+```go
+const (
+	// Default Serial Clock Bus 0 for SPI communications
+	SPI0_SCK_PIN	= GPIO6
+	// Default Serial Out Bus 0 for SPI communications
+	SPI0_SDO_PIN	= GPIO3	// Tx
+	// Default Serial In Bus 0 for SPI communications
+	SPI0_SDI_PIN	= GPIO4	// Rx
+	SPI0_CS		= GPIO5
+
+	// Default Serial Clock Bus 1 for SPI communications
+	SPI1_SCK_PIN	= GPIO26
+	// Default Serial Out Bus 1 for SPI communications
+	SPI1_SDO_PIN	= GPIO27	// Tx
+	// Default Serial In Bus 1 for SPI communications
+	SPI1_SDI_PIN	= GPIO24	// Rx
+	SPI1_CS		= GPIO25
+)
+```
+
+SPI default pins
+
+
+```go
+const (
+	UART0_TX_PIN	= GPIO28
+	UART0_RX_PIN	= GPIO29
+	UART1_TX_PIN	= GPIO20
+	UART1_RX_PIN	= GPIO5
+	UART_TX_PIN	= UART0_TX_PIN
+	UART_RX_PIN	= UART0_RX_PIN
+)
+```
+
+UART pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	LS_SE0	= 0b00
+	LS_J	= 0b01
+	LS_K	= 0b10
+	LS_SE1	= 0b11
+)
+```
+
+
+
+```go
+const (
+	cpuFreq			= 200 * MHz
+	_NUMBANK0_GPIOS		= 30
+	_NUMBANK0_IRQS		= 4
+	_NUMIRQ			= 32
+	rp2350ExtraReg		= 0
+	RESETS_RESET_Msk	= 0x01ffffff
+	initUnreset		= rp.RESETS_RESET_ADC |
+		rp.RESETS_RESET_RTC |
+		rp.RESETS_RESET_SPI0 |
+		rp.RESETS_RESET_SPI1 |
+		rp.RESETS_RESET_UART0 |
+		rp.RESETS_RESET_UART1 |
+		rp.RESETS_RESET_USBCTRL
+	initDontReset	= rp.RESETS_RESET_IO_QSPI |
+		rp.RESETS_RESET_PADS_QSPI |
+		rp.RESETS_RESET_PLL_USB |
+		rp.RESETS_RESET_USBCTRL |
+		rp.RESETS_RESET_SYSCFG |
+		rp.RESETS_RESET_PLL_SYS
+	padEnableMask	= rp.PADS_BANK0_GPIO0_IE_Msk |
+		rp.PADS_BANK0_GPIO0_OD_Msk
+)
+```
+
+
+
+```go
+const (
+	PinOutput	PinMode	= iota
+	PinInput
+	PinInputPulldown
+	PinInputPullup
+	PinAnalog
+	PinUART
+	PinPWM
+	PinI2C
+	PinSPI
+	PinPIO0
+	PinPIO1
+)
+```
+
+
+
+```go
+const (
+	ADC0	Pin	= GPIO26
+	ADC1	Pin	= GPIO27
+	ADC2	Pin	= GPIO28
+	ADC3	Pin	= GPIO29
+
+	thermADC	= 30
+)
+```
+
+Analog pins on RP2040.
+
+
+```go
+const (
+	// Edge falling
+	PinFalling	PinChange	= 4 << iota
+	// Edge rising
+	PinRising
+
+	PinToggle	= PinFalling | PinRising
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// GPIO pins
+	GPIO0	Pin	= 0	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO1	Pin	= 1	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO2	Pin	= 2	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO3	Pin	= 3	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO4	Pin	= 4	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO5	Pin	= 5	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO6	Pin	= 6	// peripherals: PWM3 channel A, I2C1 SDA
+	GPIO7	Pin	= 7	// peripherals: PWM3 channel B, I2C1 SCL
+	GPIO8	Pin	= 8	// peripherals: PWM4 channel A, I2C0 SDA
+	GPIO9	Pin	= 9	// peripherals: PWM4 channel B, I2C0 SCL
+	GPIO10	Pin	= 10	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO11	Pin	= 11	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO12	Pin	= 12	// peripherals: PWM6 channel A, I2C0 SDA
+	GPIO13	Pin	= 13	// peripherals: PWM6 channel B, I2C0 SCL
+	GPIO14	Pin	= 14	// peripherals: PWM7 channel A, I2C1 SDA
+	GPIO15	Pin	= 15	// peripherals: PWM7 channel B, I2C1 SCL
+	GPIO16	Pin	= 16	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO17	Pin	= 17	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO18	Pin	= 18	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO19	Pin	= 19	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO20	Pin	= 20	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO21	Pin	= 21	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO22	Pin	= 22	// peripherals: PWM3 channel A
+	GPIO23	Pin	= 23	// peripherals: PWM3 channel B
+	GPIO24	Pin	= 24	// peripherals: PWM4 channel A
+	GPIO25	Pin	= 25	// peripherals: PWM4 channel B
+	GPIO26	Pin	= 26	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO27	Pin	= 27	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO28	Pin	= 28	// peripherals: PWM6 channel A
+	GPIO29	Pin	= 29	// peripherals: PWM6 channel B
+)
+```
+
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 8.3s).
+	//
+	// Nominal 1us per watchdog tick, 24-bit counter,
+	// but due to errata two ticks consumed per 1us.
+	// See: Errata RP2040-E1
+	WatchdogMaxTimeout = (rp.WATCHDOG_LOAD_LOAD_Msk / 1000) / 2
+)
+```
+
+
+
+```go
+const XOSC_STARTUP_DELAY_MULTIPLIER = 64
+```
+
+On some boards, the XOSC can take longer than usual to stabilize. On such
+boards, this is needed to avoid a hard fault on boot/reset. Refer to
+PICO_XOSC_STARTUP_DELAY_MULTIPLIER in the Pico SDK for additional details.
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	UART0	= &_UART0
+	_UART0	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART0,
+	}
+
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART1,
+	}
+)
+```
+
+UART on the RP2040
+
+
+```go
+var RTC = (*rtcType)(unsafe.Pointer(rp.RTC))
+```
+
+
+
+```go
+var (
+	ErrRtcDelayTooSmall	= errors.New("RTC interrupt deplay is too small, shall be at least 1 second")
+	ErrRtcDelayTooLarge	= errors.New("RTC interrupt deplay is too large, shall be no more than 1 day")
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	I2C0	= &_I2C0
+	_I2C0	= I2C{
+		Bus: rp.I2C0,
+	}
+	I2C1	= &_I2C1
+	_I2C1	= I2C{
+		Bus: rp.I2C1,
+	}
+)
+```
+
+I2C on the RP2040/RP2350
+
+
+```go
+var (
+	ErrBadPeriod = errors.New("period outside valid range 8ns..268ms")
+)
+```
+
+
+
+```go
+var (
+	PWM0	= getPWMGroup(0)
+	PWM1	= getPWMGroup(1)
+	PWM2	= getPWMGroup(2)
+	PWM3	= getPWMGroup(3)
+	PWM4	= getPWMGroup(4)
+	PWM5	= getPWMGroup(5)
+	PWM6	= getPWMGroup(6)
+	PWM7	= getPWMGroup(7)
+)
+```
+
+Hardware Pulse Width Modulation (PWM) API
+PWM peripherals available on RP2040. Each peripheral has 2 pins available for
+a total of 16 available PWM outputs. Some pins may not be available on some boards.
+
+The RP2040 PWM block has 8 identical slices. Each slice can drive two PWM output signals, or
+measure the frequency or duty cycle of an input signal. This gives a total of up to 16 controllable
+PWM outputs. All 30 GPIOs can be driven by the PWM block
+
+The PWM hardware functions by continuously comparing the input value to a free-running counter. This produces a
+toggling output where the amount of time spent at the high output level is proportional to the input value. The fraction of
+time spent at the high signal level is known as the duty cycle of the signal.
+
+The default behaviour of a PWM slice is to count upward until the wrap value (\ref pwm_config_set_wrap) is reached, and then
+immediately wrap to 0. PWM slices also offer a phase-correct mode, where the counter starts to count downward after
+reaching TOP, until it reaches 0 again.
+
+
+```go
+var (
+	SPI0	= &SPI{
+		Bus: rp.SPI0,
+	}
+	SPI1	= &SPI{
+		Bus: rp.SPI1,
+	}
+)
+```
+
+SPI on the RP2040
+
+
+```go
+var (
+	ErrLSBNotSupported	= errors.New("SPI LSB unsupported on PL022")
+	ErrSPITimeout		= errors.New("SPI timeout")
+	ErrSPIBaud		= errors.New("SPI baud too low or above 66.5Mhz")
+	errSPIInvalidSDI	= errors.New("invalid SPI SDI pin")
+	errSPIInvalidSDO	= errors.New("invalid SPI SDO pin")
+	errSPIInvalidSCK	= errors.New("invalid SPI SCK pin")
+)
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the RP2040.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ChipVersion
+
+```go
+func ChipVersion() uint8
+```
+
+ChipVersion returns the version of the chip. 1 is returned for B0 and B1
+chip.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func CurrentCore
+
+```go
+func CurrentCore() int
+```
+
+CurrentCore returns the core number the call was made from.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of semi-random data based on ring oscillator.
+
+Unlike some other implementations of GetRNG, these random numbers are not
+cryptographically secure and must not be used for cryptographic operations
+(nonces, etc).
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC resets the ADC peripheral.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func NumCores
+
+```go
+func NumCores() int
+```
+
+NumCores returns number of cores available on the device.
+
+
+### func PWMPeripheral
+
+```go
+func PWMPeripheral(pin Pin) (sliceNum uint8, err error)
+```
+
+Peripheral returns the RP2040 PWM peripheral which ranges from 0 to 7. Each
+PWM peripheral has 2 channels, A and B which correspond to 0 and 1 in the program.
+This number corresponds to the package's PWM0 throughout PWM7 handles
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() (millicelsius int32)
+```
+
+ReadTemperature does a one-shot sample of the internal temperature sensor and returns a milli-celsius reading.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig) error
+```
+
+Configure sets the ADC pin to analog input mode.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns a one-shot ADC sample reading.
+
+
+### func (ADC) GetADCChannel
+
+```go
+func (a ADC) GetADCChannel() (c ADCChannel, err error)
+```
+
+GetADCChannel returns the channel associated with the ADC pin.
+
+
+
+
+## type ADCChannel
+
+```go
+type ADCChannel uint8
+```
+
+ADCChannel is the ADC peripheral mux channel. 0-4.
+
+
+
+### func (ADCChannel) Configure
+
+```go
+func (c ADCChannel) Configure(config ADCConfig) error
+```
+
+Configure sets the channel's associated pin to analog input mode.
+The powered on temperature sensor increases ADC_AVDD current by approximately 40 μA.
+
+
+### func (ADCChannel) Pin
+
+```go
+func (c ADCChannel) Pin() (p Pin, err error)
+```
+
+The Pin method returns the GPIO Pin associated with the ADC mux channel, if it has one.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*rp.I2C0_Type
+	mode		I2CMode
+	txInProgress	bool
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure initializes i2c peripheral and configures I2C config's pins passed.
+Here's a list of valid SDA and SCL GPIO pins on bus I2C0 of the rp2040:
+
+	SDA: 0, 4, 8, 12, 16, 20
+	SCL: 1, 5, 9, 13, 17, 21
+
+Same as above for I2C1 bus:
+
+	SDA: 2, 6, 10, 14, 18, 26
+	SCL: 3, 7, 11, 15, 19, 27
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint16) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx performs a write and then a read transfer placing the result in
+in r.
+
+Passing a nil value for w or r skips the transfer corresponding to write
+or read, respectively.
+
+	i2c.Tx(addr, nil, r)
+
+Performs only a read transfer.
+
+	i2c.Tx(addr, w, nil)
+
+Performs only a write transfer.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	// SDA/SCL Serial Data and clock pins. Refer to datasheet to see
+	// which pins match the desired bus.
+	SDA, SCL	Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure configures the gpio pin as per mode.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get reads the pin value.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set drives the pin high if value is true else drives it low.
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+PinChange represents one or more trigger events that can happen on a given GPIO pin
+on the RP2040. ORed PinChanges are valid input to most IRQ functions.
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus *rp.SPI0_Type
+}
+```
+
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup/initialize the SPI interface.
+Default baudrate of 4MHz is used if Frequency == 0. Default
+word length (data bits) is 8.
+Below is a list of GPIO pins corresponding to SPI0 bus on the rp2040:
+
+	SI : 0, 4, 17  a.k.a RX and MISO (if rp2040 is master)
+	SO : 3, 7, 19  a.k.a TX and MOSI (if rp2040 is master)
+	SCK: 2, 6, 18
+
+SPI1 bus GPIO pins:
+
+	SI : 8, 12
+	SO : 11, 15
+	SCK: 10, 14
+
+No pin configuration is needed of SCK, SDO and SDI needed after calling Configure.
+
+
+### func (*SPI) GetBaudRate
+
+```go
+func (spi *SPI) GetBaudRate() uint32
+```
+
+
+
+### func (*SPI) PrintRegs
+
+```go
+func (spi *SPI) PrintRegs()
+```
+
+PrintRegs prints SPI's peripheral common registries current values
+
+
+### func (*SPI) SetBaudRate
+
+```go
+func (spi *SPI) SetBaudRate(br uint32) error
+```
+
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Write a single byte and read a single byte from TX/RX FIFO.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) (err error)
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+Remark: This implementation (RP2040) allows reading into buffer with a custom repeated
+value on tx.
+
+	spi.Tx([]byte{0xff}, rx) // may cause unwanted heap allocations.
+
+This form sends 0xff and puts the result into rx buffer. Useful for reading from SD cards
+which require 0xff input on SI.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	// LSB not supported on rp2040.
+	LSBFirst	bool
+	// Mode's two most LSB are CPOL and CPHA. i.e. Mode==2 (0b10) is CPOL=1, CPHA=0
+	Mode	uint8
+	// Serial clock pin
+	SCK	Pin
+	// TX or Serial Data Out (MOSI if rp2040 is master)
+	SDO	Pin
+	// RX or Serial Data In (MISO if rp2040 is master)
+	SDI	Pin
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*rp.UART0_Type
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the RP2040.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the baudrate to be used for the UART.
+
+
+### func (*UART) SetFormat
+
+```go
+func (uart *UART) SetFormat(databits, stopbits uint8, parity UARTParity) error
+```
+
+SetFormat for number of data bits, stop bits, and parity for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) ClearStallEPIn
+
+```go
+func (dev *USBDevice) ClearStallEPIn(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB IN endpoint.
+
+
+### func (*USBDevice) ClearStallEPOut
+
+```go
+func (dev *USBDevice) ClearStallEPOut(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB OUT endpoint.
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+### func (*USBDevice) SetStallEPIn
+
+```go
+func (dev *USBDevice) SetStallEPIn(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB IN endpoint.
+
+
+### func (*USBDevice) SetStallEPOut
+
+```go
+func (dev *USBDevice) SetStallEPOut(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB OUT endpoint.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/qtpy.md b/content/docs/reference/microcontrollers/machine/qtpy.md
new file mode 100644
index 00000000..9f2051fb
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/qtpy.md
@@ -0,0 +1,1752 @@
+
+---
+title: qtpy
+---
+
+
+## Constants
+
+```go
+const (
+	PA00	Pin	= 0	// peripherals: TCC2 channel 0, sercomI2CM1 SDA
+	PA01	Pin	= 1	// peripherals: TCC2 channel 1, sercomI2CM1 SCL
+	PA02	Pin	= 2
+	PA03	Pin	= 3
+	PA04	Pin	= 4	// peripherals: TCC0 channel 0
+	PA05	Pin	= 5	// peripherals: TCC0 channel 1
+	PA06	Pin	= 6	// peripherals: TCC1 channel 0
+	PA07	Pin	= 7	// peripherals: TCC1 channel 1
+	PA08	Pin	= 8	// peripherals: TCC0 channel 0, TCC1 channel 2, sercomI2CM0 SDA, sercomI2CM2 SDA
+	PA09	Pin	= 9	// peripherals: TCC0 channel 1, TCC1 channel 3, sercomI2CM0 SCL, sercomI2CM2 SCL
+	PA10	Pin	= 10	// peripherals: TCC1 channel 0, TCC0 channel 2
+	PA11	Pin	= 11	// peripherals: TCC1 channel 1, TCC0 channel 3
+	PA12	Pin	= 12	// peripherals: TCC2 channel 0, TCC0 channel 2, sercomI2CM2 SDA, sercomI2CM4 SDA
+	PA13	Pin	= 13	// peripherals: TCC2 channel 1, TCC0 channel 3, sercomI2CM2 SCL, sercomI2CM4 SCL
+	PA14	Pin	= 14	// peripherals: TCC0 channel 0
+	PA15	Pin	= 15	// peripherals: TCC0 channel 1
+	PA16	Pin	= 16	// peripherals: TCC2 channel 0, TCC0 channel 2, sercomI2CM1 SDA, sercomI2CM3 SDA
+	PA17	Pin	= 17	// peripherals: TCC2 channel 1, TCC0 channel 3, sercomI2CM1 SCL, sercomI2CM3 SCL
+	PA18	Pin	= 18	// peripherals: TCC0 channel 2
+	PA19	Pin	= 19	// peripherals: TCC0 channel 3
+	PA20	Pin	= 20	// peripherals: TCC0 channel 2
+	PA21	Pin	= 21	// peripherals: TCC0 channel 3
+	PA22	Pin	= 22	// peripherals: TCC0 channel 0, sercomI2CM3 SDA, sercomI2CM5 SDA
+	PA23	Pin	= 23	// peripherals: TCC0 channel 1, sercomI2CM3 SCL, sercomI2CM5 SCL
+	PA24	Pin	= 24	// peripherals: TCC1 channel 2
+	PA25	Pin	= 25	// peripherals: TCC1 channel 3
+	PA26	Pin	= 26
+	PA27	Pin	= 27
+	PA28	Pin	= 28
+	PA29	Pin	= 29
+	PA30	Pin	= 30	// peripherals: TCC1 channel 0
+	PA31	Pin	= 31	// peripherals: TCC1 channel 1
+	PB00	Pin	= 32
+	PB01	Pin	= 33
+	PB02	Pin	= 34	// peripherals: sercomI2CM5 SDA
+	PB03	Pin	= 35	// peripherals: sercomI2CM5 SCL
+	PB04	Pin	= 36
+	PB05	Pin	= 37
+	PB06	Pin	= 38
+	PB07	Pin	= 39
+	PB08	Pin	= 40	// peripherals: sercomI2CM4 SDA
+	PB09	Pin	= 41	// peripherals: sercomI2CM4 SCL
+	PB10	Pin	= 42	// peripherals: TCC0 channel 0
+	PB11	Pin	= 43	// peripherals: TCC0 channel 1
+	PB12	Pin	= 44	// peripherals: TCC0 channel 2, sercomI2CM4 SDA
+	PB13	Pin	= 45	// peripherals: TCC0 channel 3, sercomI2CM4 SCL
+	PB14	Pin	= 46
+	PB15	Pin	= 47
+	PB16	Pin	= 48	// peripherals: TCC0 channel 0, sercomI2CM5 SDA
+	PB17	Pin	= 49	// peripherals: TCC0 channel 1, sercomI2CM5 SCL
+	PB18	Pin	= 50
+	PB19	Pin	= 51
+	PB20	Pin	= 52
+	PB21	Pin	= 53
+	PB22	Pin	= 54
+	PB23	Pin	= 55
+	PB24	Pin	= 56
+	PB25	Pin	= 57
+	PB26	Pin	= 58
+	PB27	Pin	= 59
+	PB28	Pin	= 60
+	PB29	Pin	= 61
+	PB30	Pin	= 62	// peripherals: TCC0 channel 0, TCC1 channel 2, sercomI2CM5 SDA
+	PB31	Pin	= 63	// peripherals: TCC0 channel 1, TCC1 channel 3, sercomI2CM5 SCL
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	D0	= PA02	// PWM available
+	D1	= PA03
+	D2	= PA04	// PWM available
+	D3	= PA05	// PWM available
+	D4	= PA16	// PWM available
+	D5	= PA17	// PWM available
+	D6	= PA06
+	D7	= PA07
+	D8	= PA11
+	D9	= PA09
+	D10	= PA10
+	D11	= PA18
+	D12	= PA15
+	D13	= PA27
+	D14	= PA23
+	D15	= PA19
+	D16	= PA22
+	D17	= PA08
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A0	= D0
+	A1	= D1
+	A2	= D2
+	A3	= D3
+	A4	= D4
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	NEOPIXELS	= D11
+	WS2812		= D11
+	NEOPIXELS_POWER	= D12
+)
+```
+
+
+
+```go
+const (
+	USBCDC_DM_PIN	= PA24
+	USBCDC_DP_PIN	= PA25
+)
+```
+
+USBCDC pins
+
+
+```go
+const (
+	UART_TX_PIN	= D6
+	UART_RX_PIN	= D7
+)
+```
+
+UART1 pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= D8
+	SPI0_SDO_PIN	= D10
+	SPI0_SDI_PIN	= D9
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	SDA_PIN	= D4	// SDA
+	SCL_PIN	= D5	// SCL
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	I2S_SCK_PIN	= PA10
+	I2S_SDO_PIN	= PA08
+	I2S_SDI_PIN	= NoPin	// TODO: figure out what this is on QT Py M0.
+	I2S_WS_PIN	= NoPin	// TODO: figure out what this is on QT Py M0.
+)
+```
+
+I2S pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const (
+	I2SModeSource	I2SMode	= iota
+	I2SModeReceiver
+	I2SModePDM
+	I2SModeSourceReceiver
+)
+```
+
+
+
+```go
+const (
+	I2StandardPhilips	I2SStandard	= iota
+	I2SStandardMSB
+	I2SStandardLSB
+)
+```
+
+
+
+```go
+const (
+	I2SClockSourceInternal	I2SClockSource	= iota
+	I2SClockSourceExternal
+)
+```
+
+
+
+```go
+const (
+	I2SDataFormatDefault	I2SDataFormat	= 0
+	I2SDataFormat8bit			= 8
+	I2SDataFormat16bit			= 16
+	I2SDataFormat24bit			= 24
+	I2SDataFormat32bit			= 32
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinAnalog	PinMode	= 1
+	PinSERCOM	PinMode	= 2
+	PinSERCOMAlt	PinMode	= 3
+	PinTimer	PinMode	= 4
+	PinTimerAlt	PinMode	= 5
+	PinCom		PinMode	= 6
+	//PinAC_CLK        PinMode = 7
+	PinDigital		PinMode	= 8
+	PinInput		PinMode	= 9
+	PinInputPullup		PinMode	= 10
+	PinOutput		PinMode	= 11
+	PinTCC			PinMode	= PinTimer
+	PinTCCAlt		PinMode	= PinTimerAlt
+	PinInputPulldown	PinMode	= 12
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
+	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
+	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (16s)
+	WatchdogMaxTimeout = (16384 * 1000) / 1024
+)
+```
+
+
+
+```go
+const (
+	// these are SAMD21 specific.
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Pos	= 0
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Mask	= 0x3FFF
+
+	usb_DEVICE_PCKSIZE_SIZE_Pos	= 28
+	usb_DEVICE_PCKSIZE_SIZE_Mask	= 0x7
+
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Pos	= 14
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Mask	= 0x3FFF
+
+	NumberOfUSBEndpoints	= 8
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var UART1 = &sercomUSART0
+```
+
+UART1 on the QT Py M0.
+
+
+```go
+var SPI0 = sercomSPIM0
+```
+
+SPI on the QT Py M0.
+
+
+```go
+var (
+	I2C0 = sercomI2CM1
+)
+```
+
+I2C on the QT Py M0.
+
+
+```go
+var (
+	DefaultUART = UART1
+)
+```
+
+
+
+```go
+var (
+	ErrInvalidSampleFrequency = errors.New("i2s: invalid sample frequency")
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var I2S0 = I2S{Bus: sam.I2S}
+```
+
+
+
+```go
+var (
+	TCC0	= (*TCC)(sam.TCC0)
+	TCC1	= (*TCC)(sam.TCC1)
+	TCC2	= (*TCC)(sam.TCC2)
+)
+```
+
+The SAM D21 has three TCC peripherals, which have PWM as one feature.
+
+
+```go
+var (
+	DAC0 = DAC{}
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the SAMD21.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+Return the current CPU frequency in hertz.
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) and 16 bytes (128 bits) are common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig)
+```
+
+Configure configures a ADC pin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type DAC
+
+```go
+type DAC struct {
+}
+```
+
+DAC on the SAMD21.
+
+
+
+### func (DAC) Configure
+
+```go
+func (dac DAC) Configure(config DACConfig)
+```
+
+Configure the DAC.
+output pin must already be configured.
+
+
+### func (DAC) Set
+
+```go
+func (dac DAC) Set(value uint16) error
+```
+
+Set writes a single 16-bit value to the DAC.
+Since the ATSAMD21 only has a 10-bit DAC, the passed-in value will be scaled down.
+
+
+
+
+## type DACConfig
+
+```go
+type DACConfig struct {
+}
+```
+
+DACConfig placeholder for future expansion.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*sam.SERCOM_I2CM_Type
+	SERCOM	uint8
+}
+```
+
+I2C on the SAMD21.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteByte
+
+```go
+func (i2c *I2C) WriteByte(data byte) error
+```
+
+WriteByte writes a single byte to the I2C bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type I2S
+
+```go
+type I2S struct {
+	Bus		*sam.I2S_Type
+	Frequency	uint32
+	DataFormat	I2SDataFormat
+}
+```
+
+I2S
+
+
+
+### func (*I2S) Configure
+
+```go
+func (i2s *I2S) Configure(config I2SConfig) error
+```
+
+Configure is used to configure the I2S interface. You must call this
+before you can use the I2S bus.
+
+
+### func (*I2S) Enable
+
+```go
+func (i2s *I2S) Enable(enabled bool)
+```
+
+Enabled is used to enable or disable the I2S bus.
+
+
+### func (*I2S) ReadMono
+
+```go
+func (i2s *I2S) ReadMono(p []uint16) (n int, err error)
+```
+
+Read mono data from the I2S bus into the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) ReadStereo
+
+```go
+func (i2s *I2S) ReadStereo(p []uint32) (n int, err error)
+```
+
+Read stereo data from the I2S bus into the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) SetSampleFrequency
+
+```go
+func (i2s *I2S) SetSampleFrequency(freq uint32) error
+```
+
+SetSampleFrequency is used to set the sample frequency for the I2S bus.
+
+
+### func (*I2S) WriteMono
+
+```go
+func (i2s *I2S) WriteMono(p []uint16) (n int, err error)
+```
+
+Write mono data to the I2S bus from the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) WriteStereo
+
+```go
+func (i2s *I2S) WriteStereo(p []uint32) (n int, err error)
+```
+
+Write stereo data to the I2S bus from the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+
+
+## type I2SClockSource
+
+```go
+type I2SClockSource uint8
+```
+
+
+
+
+
+
+## type I2SConfig
+
+```go
+type I2SConfig struct {
+	// clock
+	SCK	Pin
+	// word select
+	WS	Pin
+	// data out
+	SDO	Pin
+	// data in
+	SDI		Pin
+	Mode		I2SMode
+	Standard	I2SStandard
+	ClockSource	I2SClockSource
+	DataFormat	I2SDataFormat
+	AudioFrequency	uint32
+	MainClockOutput	bool
+	Stereo		bool
+}
+```
+
+All fields are optional and may not be required or used on a particular platform.
+
+
+
+
+
+## type I2SDataFormat
+
+```go
+type I2SDataFormat uint8
+```
+
+
+
+
+
+
+## type I2SMode
+
+```go
+type I2SMode uint8
+```
+
+
+
+
+
+
+## type I2SStandard
+
+```go
+type I2SStandard uint8
+```
+
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when configured as an input or as
+an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*sam.SERCOM_SPI_Type
+	SERCOM	uint8
+}
+```
+
+SPI
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type TCC
+
+```go
+type TCC sam.TCC_Type
+```
+
+TCC is one timer/counter peripheral, which consists of a counter and multiple
+output channels (that can be connected to actual pins). You can set the
+frequency using SetPeriod, but only for all the channels in this TCC
+peripheral at once.
+
+
+
+### func (*TCC) Channel
+
+```go
+func (tcc *TCC) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin. Note that one channel may be
+shared between multiple pins, and so will have the same duty cycle. If this
+is not desirable, look for a different TCC peripheral or consider using a
+different pin.
+
+
+### func (*TCC) Configure
+
+```go
+func (tcc *TCC) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this TCC.
+
+
+### func (*TCC) Counter
+
+```go
+func (tcc *TCC) Counter() uint32
+```
+
+Counter returns the current counter value of the timer in this TCC
+peripheral. It may be useful for debugging.
+
+
+### func (*TCC) Set
+
+```go
+func (tcc *TCC) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle, in other words the fraction of time the channel output is high (or low
+when inverted). For example, to set it to a 25% duty cycle, use:
+
+	tcc.Set(channel, tcc.Top() / 4)
+
+tcc.Set(channel, 0) will set the output to low and tcc.Set(channel,
+tcc.Top()) will set the output to high, assuming the output isn't inverted.
+
+
+### func (*TCC) SetInverting
+
+```go
+func (tcc *TCC) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TCC) SetPeriod
+
+```go
+func (tcc *TCC) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this TCC peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the TCC peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TCC) Top
+
+```go
+func (tcc *TCC) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to Set
+(see Set documentation for more information).
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*sam.SERCOM_USART_Type
+	SERCOM		uint8
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the SAMD21.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/reelboard.md b/content/docs/reference/microcontrollers/machine/reelboard.md
new file mode 100644
index 00000000..af58416c
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/reelboard.md
@@ -0,0 +1,1526 @@
+
+---
+title: reelboard
+---
+
+
+## Constants
+
+```go
+const (
+	P0_00	Pin	= 0
+	P0_01	Pin	= 1
+	P0_02	Pin	= 2
+	P0_03	Pin	= 3
+	P0_04	Pin	= 4
+	P0_05	Pin	= 5
+	P0_06	Pin	= 6
+	P0_07	Pin	= 7
+	P0_08	Pin	= 8
+	P0_09	Pin	= 9
+	P0_10	Pin	= 10
+	P0_11	Pin	= 11
+	P0_12	Pin	= 12
+	P0_13	Pin	= 13
+	P0_14	Pin	= 14
+	P0_15	Pin	= 15
+	P0_16	Pin	= 16
+	P0_17	Pin	= 17
+	P0_18	Pin	= 18
+	P0_19	Pin	= 19
+	P0_20	Pin	= 20
+	P0_21	Pin	= 21
+	P0_22	Pin	= 22
+	P0_23	Pin	= 23
+	P0_24	Pin	= 24
+	P0_25	Pin	= 25
+	P0_26	Pin	= 26
+	P0_27	Pin	= 27
+	P0_28	Pin	= 28
+	P0_29	Pin	= 29
+	P0_30	Pin	= 30
+	P0_31	Pin	= 31
+	P1_00	Pin	= 32
+	P1_01	Pin	= 33
+	P1_02	Pin	= 34
+	P1_03	Pin	= 35
+	P1_04	Pin	= 36
+	P1_05	Pin	= 37
+	P1_06	Pin	= 38
+	P1_07	Pin	= 39
+	P1_08	Pin	= 40
+	P1_09	Pin	= 41
+	P1_10	Pin	= 42
+	P1_11	Pin	= 43
+	P1_12	Pin	= 44
+	P1_13	Pin	= 45
+	P1_14	Pin	= 46
+	P1_15	Pin	= 47
+)
+```
+
+Hardware pins
+
+
+```go
+const HasLowFrequencyCrystal = true
+```
+
+
+
+```go
+const (
+	LED_RED			Pin	= 11
+	LED_GREEN		Pin	= 12
+	LED_BLUE		Pin	= 41
+	LED_YELLOW		Pin	= 13
+	LED1			Pin	= LED_YELLOW
+	LED2			Pin	= LED_RED
+	LED3			Pin	= LED_GREEN
+	LED4			Pin	= LED_BLUE
+	LED			Pin	= LED1
+	EPD_BUSY_PIN		Pin	= 14
+	EPD_RESET_PIN		Pin	= 15
+	EPD_DC_PIN		Pin	= 16
+	EPD_CS_PIN		Pin	= 17
+	EPD_SCK_PIN		Pin	= 19
+	EPD_SDO_PIN		Pin	= 20
+	POWER_SUPPLY_PIN	Pin	= 32
+)
+```
+
+Pins on the reel board
+
+
+```go
+const (
+	BUTTON Pin = 7
+)
+```
+
+User "a" button on the reel board
+
+
+```go
+const (
+	UART_TX_PIN	Pin	= 6
+	UART_RX_PIN	Pin	= 8
+)
+```
+
+UART pins
+
+
+```go
+const (
+	SDA_PIN	Pin	= 26
+	SCL_PIN	Pin	= 27
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	Pin	= 47
+	SPI0_SDO_PIN	Pin	= 45
+	SPI0_SDI_PIN	Pin	= 46
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
+	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
+	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 36h)
+	WatchdogMaxTimeout = (0xffffffff * 1000) / 32768
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	// UART0 is the hardware UART on the NRF SoC.
+	_UART0	= UART{Buffer: NewRingBuffer()}
+	UART0	= &_UART0
+)
+```
+
+UART
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	PWM0	= &PWM{PWM: nrf.PWM0}
+	PWM1	= &PWM{PWM: nrf.PWM1}
+	PWM2	= &PWM{PWM: nrf.PWM2}
+	PWM3	= &PWM{PWM: nrf.PWM3}
+)
+```
+
+PWM
+
+
+```go
+var (
+	I2C0	= &I2C{Bus: nrf.TWIM0, BusT: nrf.TWIS0}
+	I2C1	= &I2C{Bus: nrf.TWIM1, BusT: nrf.TWIS1}
+)
+```
+
+There are 2 I2C interfaces on the NRF.
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	SPI0	= &SPI{Bus: nrf.SPIM0, buf: new([1]byte)}
+	SPI1	= &SPI{Bus: nrf.SPIM1, buf: new([1]byte)}
+	SPI2	= &SPI{Bus: nrf.SPIM2, buf: new([1]byte)}
+)
+```
+
+There are 3 SPI interfaces on the NRF528xx.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader resets the chip into the serial bootloader.
+
+
+### func EnterOTABootloader
+
+```go
+func EnterOTABootloader()
+```
+
+EnterOTABootloader resets the chip into the bootloader so that it can be
+flashed via an OTA update
+
+
+### func EnterSerialBootloader
+
+```go
+func EnterSerialBootloader()
+```
+
+EnterSerialBootloader resets the chip into the serial bootloader. After
+reset, it can be flashed using serial/nrfutil.
+
+
+### func EnterUF2Bootloader
+
+```go
+func EnterUF2Bootloader()
+```
+
+EnterUF2Bootloader resets the chip into the UF2 bootloader. After reset, it
+can be flashed via nrfutil or by copying a UF2 file to the mass storage device
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (ret uint32, err error)
+```
+
+GetRNG returns 32 bits of non-deterministic random data based on internal thermal noise.
+According to Nordic's documentation, the random output is suitable for cryptographic purposes.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func PowerSupplyActive
+
+```go
+func PowerSupplyActive(active bool)
+```
+
+PowerSupplyActive enables the supply voltages for nRF52840 and peripherals (true) or only for nRF52840 (false)
+This controls the TPS610981 boost converter. You must turn the power supply active in order to use the EPD and
+other onboard peripherals.
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() int32
+```
+
+ReadTemperature reads the silicon die temperature of the chip. The return
+value is in milli-celsius.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USBHID (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (*ADC) Configure
+
+```go
+func (a *ADC) Configure(config ADCConfig)
+```
+
+Configure configures an ADC pin to be able to read analog data.
+Reference voltage can be 150, 300, 600, 1200, 1800, 2400, 3000(default), 3600 mV
+Resolution can be 8, 10, 12(default), 14 bits
+SampleTime will be ceiled to 3(default), 5, 10, 15, 20 or 40(max) µS respectively
+Samples can be 1(default), 2, 4, 8, 16, 32, 64, 128, 256 samples
+
+
+### func (*ADC) Get
+
+```go
+func (a *ADC) Get() uint16
+```
+
+Get returns the current value of an ADC pin in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*nrf.TWIM_Type	// Called Bus to align with Bus field in nrf51
+	BusT	*nrf.TWIS_Type
+	mode	I2CMode
+}
+```
+
+I2C on the NRF528xx.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint8) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+Reply supplies the response data the controller.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) (err error)
+```
+
+Tx does a single I2C transaction at the specified address (when in controller mode).
+
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+WaitForEvent blocks the current go-routine until an I2C event is received (when in Target mode).
+
+The passed buffer will be populated for receive events, with the number of bytes
+received returned in count.  For other event types, buf is not modified and a count
+of zero is returned.
+
+For request events, the caller MUST call `Reply` to avoid hanging the i2c bus indefinitely.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDM
+
+```go
+type PDM struct {
+	device		*nrf.PDM_Type
+	defaultBuffer	int16
+}
+```
+
+PDM represents a PDM device
+
+
+
+### func (*PDM) Configure
+
+```go
+func (pdm *PDM) Configure(config PDMConfig) error
+```
+
+Configure is intended to set up the PDM interface prior to use.
+
+
+### func (*PDM) Read
+
+```go
+func (pdm *PDM) Read(buf []int16) (uint32, error)
+```
+
+Read stores a set of samples in the given target buffer.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWM
+
+```go
+type PWM struct {
+	PWM	*nrf.PWM_Type
+
+	channelValues	[4]volatile.Register16
+}
+```
+
+PWM is one PWM peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this PWM peripheral at
+once.
+
+
+
+### func (*PWM) Channel
+
+```go
+func (pwm *PWM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*PWM) Configure
+
+```go
+func (pwm *PWM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+On the nRF52 series, the maximum period is around 0.26s.
+
+
+### func (*PWM) Set
+
+```go
+func (pwm *PWM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	ch.Set(ch.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*PWM) SetInverting
+
+```go
+func (pwm *PWM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*PWM) SetPeriod
+
+```go
+func (pwm *PWM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*PWM) Top
+
+```go
+func (pwm *PWM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*nrf.SPIM_Type
+	buf	*[1]byte	// 1-byte buffer for the Transfer method
+}
+```
+
+SPI on the NRF.
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to set up the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous
+write/read interface, there must always be the same number of bytes written
+as bytes read. Therefore, if the number of bytes don't match it will be
+padded until they fit: if len(w) > len(r) the extra bytes received will be
+dropped and if len(w) < len(r) extra 0 bytes will be sent.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer *RingBuffer
+}
+```
+
+UART on the NRF.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/stm32f4disco.md b/content/docs/reference/microcontrollers/machine/stm32f4disco.md
new file mode 100644
index 00000000..5d27a5ad
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/stm32f4disco.md
@@ -0,0 +1,1816 @@
+
+---
+title: stm32f4disco
+---
+
+
+## Constants
+
+```go
+const (
+	LED1		= LED_GREEN
+	LED2		= LED_ORANGE
+	LED3		= LED_RED
+	LED4		= LED_BLUE
+	LED_GREEN	= PD12
+	LED_ORANGE	= PD13
+	LED_RED		= PD14
+	LED_BLUE	= PD15
+	LED		= LED_BUILTIN
+	LED_BUILTIN	= LED_GREEN
+)
+```
+
+
+
+```go
+const (
+	BUTTON = PA0
+)
+```
+
+
+
+```go
+const (
+	ADC0	= PA0
+	ADC1	= PA1
+	ADC2	= PA2
+	ADC3	= PA3
+	ADC4	= PA4
+	ADC5	= PA5
+	ADC6	= PA6
+	ADC7	= PA7
+	ADC8	= PB0
+	ADC9	= PB1
+	ADC10	= PC0
+	ADC11	= PC1
+	ADC12	= PC2
+	ADC13	= PC3
+	ADC14	= PC4
+	ADC15	= PC5
+)
+```
+
+Analog Pins
+
+
+```go
+const (
+	UART_TX_PIN	= PA2
+	UART_RX_PIN	= PA3
+)
+```
+
+UART pins
+
+
+```go
+const (
+	SPI1_SCK_PIN	= PA5
+	SPI1_SDI_PIN	= PA6
+	SPI1_SDO_PIN	= PA7
+	SPI0_SCK_PIN	= SPI1_SCK_PIN
+	SPI0_SDI_PIN	= SPI1_SDI_PIN
+	SPI0_SDO_PIN	= SPI1_SDO_PIN
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	MEMS_ACCEL_CS	= PE3
+	MEMS_ACCEL_INT1	= PE0
+	MEMS_ACCEL_INT2	= PE1
+)
+```
+
+MEMs accelerometer
+
+
+```go
+const (
+	I2C0_SCL_PIN	= PB6
+	I2C0_SDA_PIN	= PB9
+)
+```
+
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinRising	PinChange	= 1 << iota
+	PinFalling
+	PinToggle	= PinRising | PinFalling
+)
+```
+
+
+
+```go
+const (
+	DutyCycle2	= 0
+	DutyCycle16x9	= 1
+)
+```
+
+I2C fast mode (Fm) duty cycle
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (32.768s)
+	//
+	// Timeout is based on 12-bit counter with /256 divider on
+	// 32.768kHz clock.  See 21.3.3 of RM0090 for table.
+	WatchdogMaxTimeout = ((0xfff + 1) * 256 * 1024) / 32768
+)
+```
+
+
+
+```go
+const (
+	// Mode Flag
+	PinOutput		PinMode	= 0
+	PinInput		PinMode	= PinInputFloating
+	PinInputFloating	PinMode	= 1
+	PinInputPulldown	PinMode	= 2
+	PinInputPullup		PinMode	= 3
+
+	// for UART
+	PinModeUARTTX	PinMode	= 4
+	PinModeUARTRX	PinMode	= 5
+
+	// for I2C
+	PinModeI2CSCL	PinMode	= 6
+	PinModeI2CSDA	PinMode	= 7
+
+	// for SPI
+	PinModeSPICLK	PinMode	= 8
+	PinModeSPISDO	PinMode	= 9
+	PinModeSPISDI	PinMode	= 10
+
+	// for analog/ADC
+	PinInputAnalog	PinMode	= 11
+
+	// for PWM
+	PinModePWMOutput	PinMode	= 12
+)
+```
+
+
+
+```go
+const RNG_MAX_READ_RETRIES = 1000
+```
+
+
+
+```go
+const PWM_MODE1 = 0x6
+```
+
+
+
+```go
+const (
+	PA0	= portA + 0
+	PA1	= portA + 1
+	PA2	= portA + 2
+	PA3	= portA + 3
+	PA4	= portA + 4
+	PA5	= portA + 5
+	PA6	= portA + 6
+	PA7	= portA + 7
+	PA8	= portA + 8
+	PA9	= portA + 9
+	PA10	= portA + 10
+	PA11	= portA + 11
+	PA12	= portA + 12
+	PA13	= portA + 13
+	PA14	= portA + 14
+	PA15	= portA + 15
+
+	PB0	= portB + 0
+	PB1	= portB + 1
+	PB2	= portB + 2
+	PB3	= portB + 3
+	PB4	= portB + 4
+	PB5	= portB + 5
+	PB6	= portB + 6
+	PB7	= portB + 7
+	PB8	= portB + 8
+	PB9	= portB + 9
+	PB10	= portB + 10
+	PB11	= portB + 11
+	PB12	= portB + 12
+	PB13	= portB + 13
+	PB14	= portB + 14
+	PB15	= portB + 15
+
+	PC0	= portC + 0
+	PC1	= portC + 1
+	PC2	= portC + 2
+	PC3	= portC + 3
+	PC4	= portC + 4
+	PC5	= portC + 5
+	PC6	= portC + 6
+	PC7	= portC + 7
+	PC8	= portC + 8
+	PC9	= portC + 9
+	PC10	= portC + 10
+	PC11	= portC + 11
+	PC12	= portC + 12
+	PC13	= portC + 13
+	PC14	= portC + 14
+	PC15	= portC + 15
+
+	PD0	= portD + 0
+	PD1	= portD + 1
+	PD2	= portD + 2
+	PD3	= portD + 3
+	PD4	= portD + 4
+	PD5	= portD + 5
+	PD6	= portD + 6
+	PD7	= portD + 7
+	PD8	= portD + 8
+	PD9	= portD + 9
+	PD10	= portD + 10
+	PD11	= portD + 11
+	PD12	= portD + 12
+	PD13	= portD + 13
+	PD14	= portD + 14
+	PD15	= portD + 15
+
+	PE0	= portE + 0
+	PE1	= portE + 1
+	PE2	= portE + 2
+	PE3	= portE + 3
+	PE4	= portE + 4
+	PE5	= portE + 5
+	PE6	= portE + 6
+	PE7	= portE + 7
+	PE8	= portE + 8
+	PE9	= portE + 9
+	PE10	= portE + 10
+	PE11	= portE + 11
+	PE12	= portE + 12
+	PE13	= portE + 13
+	PE14	= portE + 14
+	PE15	= portE + 15
+
+	PF0	= portF + 0
+	PF1	= portF + 1
+	PF2	= portF + 2
+	PF3	= portF + 3
+	PF4	= portF + 4
+	PF5	= portF + 5
+	PF6	= portF + 6
+	PF7	= portF + 7
+	PF8	= portF + 8
+	PF9	= portF + 9
+	PF10	= portF + 10
+	PF11	= portF + 11
+	PF12	= portF + 12
+	PF13	= portF + 13
+	PF14	= portF + 14
+	PF15	= portF + 15
+
+	PG0	= portG + 0
+	PG1	= portG + 1
+	PG2	= portG + 2
+	PG3	= portG + 3
+	PG4	= portG + 4
+	PG5	= portG + 5
+	PG6	= portG + 6
+	PG7	= portG + 7
+	PG8	= portG + 8
+	PG9	= portG + 9
+	PG10	= portG + 10
+	PG11	= portG + 11
+	PG12	= portG + 12
+	PG13	= portG + 13
+	PG14	= portG + 14
+	PG15	= portG + 15
+
+	PH0	= portH + 0
+	PH1	= portH + 1
+	PH2	= portH + 2
+	PH3	= portH + 3
+	PH4	= portH + 4
+	PH5	= portH + 5
+	PH6	= portH + 6
+	PH7	= portH + 7
+	PH8	= portH + 8
+	PH9	= portH + 9
+	PH10	= portH + 10
+	PH11	= portH + 11
+	PH12	= portH + 12
+	PH13	= portH + 13
+	PH14	= portH + 14
+	PH15	= portH + 15
+
+	PI0	= portI + 0
+	PI1	= portI + 1
+	PI2	= portI + 2
+	PI3	= portI + 3
+	PI4	= portI + 4
+	PI5	= portI + 5
+	PI6	= portI + 6
+	PI7	= portI + 7
+	PI8	= portI + 8
+	PI9	= portI + 9
+	PI10	= portI + 10
+	PI11	= portI + 11
+	PI12	= portI + 12
+	PI13	= portI + 13
+	PI14	= portI + 14
+	PI15	= portI + 15
+
+	PK0	= portK + 0
+	PK1	= portK + 1
+	PK2	= portK + 2
+	PK3	= portK + 3
+	PK4	= portK + 4
+	PK5	= portK + 5
+	PK6	= portK + 6
+	PK7	= portK + 7
+	PK8	= portK + 8
+	PK9	= portK + 9
+	PK10	= portK + 10
+	PK11	= portK + 11
+	PK12	= portK + 12
+	PK13	= portK + 13
+	PK14	= portK + 14
+	PK15	= portK + 15
+)
+```
+
+
+
+```go
+const (
+	ARR_MAX	= 0x10000
+	PSC_MAX	= 0x10000
+)
+```
+
+
+
+```go
+const (
+	AF0_SYSTEM			= 0
+	AF1_TIM1_2			= 1
+	AF2_TIM3_4_5			= 2
+	AF3_TIM8_9_10_11		= 3
+	AF4_I2C1_2_3			= 4
+	AF5_SPI1_SPI2			= 5
+	AF6_SPI3			= 6
+	AF7_USART1_2_3			= 7
+	AF8_USART4_5_6			= 8
+	AF9_CAN1_CAN2_TIM12_13_14	= 9
+	AF10_OTG_FS_OTG_HS		= 10
+	AF11_ETH			= 11
+	AF12_FSMC_SDIO_OTG_HS_1		= 12
+	AF13_DCMI			= 13
+	AF14				= 14
+	AF15_EVENTOUT			= 15
+)
+```
+
+Alternative peripheral pin functions
+
+
+```go
+const APB1_TIM_FREQ = 42000000 * 2
+```
+
+Internal use: configured speed of the APB1 and APB2 timers, this should be kept
+in sync with any changes to runtime package which configures the oscillators
+and clock frequencies
+
+
+```go
+const APB2_TIM_FREQ = 84000000 * 2
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:			NewRingBuffer(),
+		Bus:			stm32.USART2,
+		TxAltFuncSelector:	AF7_USART1_2_3,
+		RxAltFuncSelector:	AF7_USART1_2_3,
+	}
+	DefaultUART	= UART1
+)
+```
+
+
+
+```go
+var (
+	SPI0	= &SPI{
+		Bus:			stm32.SPI1,
+		AltFuncSelector:	AF5_SPI1_SPI2,
+	}
+	SPI1	= SPI0
+)
+```
+
+Since the first interface is named SPI1, both SPI0 and SPI1 refer to SPI1.
+TODO: implement SPI2 and SPI3.
+
+
+```go
+var (
+	I2C0 = &I2C{
+		Bus:			stm32.I2C1,
+		AltFuncSelector:	AF4_I2C1_2_3,
+	}
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	TIM1	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM1EN,
+		Device:		stm32.TIM1,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA8, AF1_TIM1_2}, {PE9, AF1_TIM1_2}}},
+			TimerChannel{Pins: []PinFunction{{PA9, AF1_TIM1_2}, {PE11, AF1_TIM1_2}}},
+			TimerChannel{Pins: []PinFunction{{PA10, AF1_TIM1_2}, {PE13, AF1_TIM1_2}}},
+			TimerChannel{Pins: []PinFunction{{PA11, AF1_TIM1_2}, {PE14, AF1_TIM1_2}}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM2	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM2EN,
+		Device:		stm32.TIM2,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA0, AF1_TIM1_2}, {PA5, AF1_TIM1_2}, {PA15, AF1_TIM1_2}}},
+			TimerChannel{Pins: []PinFunction{{PA1, AF1_TIM1_2}, {PB3, AF1_TIM1_2}}},
+			TimerChannel{Pins: []PinFunction{{PA2, AF1_TIM1_2}, {PB10, AF1_TIM1_2}}},
+			TimerChannel{Pins: []PinFunction{{PA3, AF1_TIM1_2}, {PB11, AF1_TIM1_2}}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM3	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM3EN,
+		Device:		stm32.TIM3,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA6, AF2_TIM3_4_5}, {PB4, AF2_TIM3_4_5}, {PC6, AF2_TIM3_4_5}}},
+			TimerChannel{Pins: []PinFunction{{PA7, AF2_TIM3_4_5}, {PB5, AF2_TIM3_4_5}, {PC7, AF2_TIM3_4_5}}},
+			TimerChannel{Pins: []PinFunction{{PB0, AF2_TIM3_4_5}, {PC8, AF2_TIM3_4_5}}},
+			TimerChannel{Pins: []PinFunction{{PB1, AF2_TIM3_4_5}, {PC9, AF2_TIM3_4_5}}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM4	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM4EN,
+		Device:		stm32.TIM4,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PB6, AF2_TIM3_4_5}, {PD12, AF2_TIM3_4_5}}},
+			TimerChannel{Pins: []PinFunction{{PB7, AF2_TIM3_4_5}, {PD13, AF2_TIM3_4_5}}},
+			TimerChannel{Pins: []PinFunction{{PB8, AF2_TIM3_4_5}, {PD14, AF2_TIM3_4_5}}},
+			TimerChannel{Pins: []PinFunction{{PB9, AF2_TIM3_4_5}, {PD15, AF2_TIM3_4_5}}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM5	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM5EN,
+		Device:		stm32.TIM5,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PH10, AF2_TIM3_4_5}}},
+			TimerChannel{Pins: []PinFunction{{PH11, AF2_TIM3_4_5}}},
+			TimerChannel{Pins: []PinFunction{{PH12, AF2_TIM3_4_5}}},
+			TimerChannel{Pins: []PinFunction{{PI0, AF2_TIM3_4_5}}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM6	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM6EN,
+		Device:		stm32.TIM6,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM7	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM7EN,
+		Device:		stm32.TIM7,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM8	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM8EN,
+		Device:		stm32.TIM8,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PC6, AF3_TIM8_9_10_11}, {PI5, AF3_TIM8_9_10_11}}},
+			TimerChannel{Pins: []PinFunction{{PC7, AF3_TIM8_9_10_11}, {PI6, AF3_TIM8_9_10_11}}},
+			TimerChannel{Pins: []PinFunction{{PC8, AF3_TIM8_9_10_11}, {PI7, AF3_TIM8_9_10_11}}},
+			TimerChannel{Pins: []PinFunction{{PC9, AF3_TIM8_9_10_11}, {PI2, AF3_TIM8_9_10_11}}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM9	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM9EN,
+		Device:		stm32.TIM9,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA2, AF3_TIM8_9_10_11}, {PE5, AF3_TIM8_9_10_11}}},
+			TimerChannel{Pins: []PinFunction{{PA3, AF3_TIM8_9_10_11}, {PE6, AF3_TIM8_9_10_11}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM10	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM10EN,
+		Device:		stm32.TIM10,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PB8, AF3_TIM8_9_10_11}, {PF6, AF3_TIM8_9_10_11}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM11	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM11EN,
+		Device:		stm32.TIM11,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PB9, AF3_TIM8_9_10_11}, {PF7, AF3_TIM8_9_10_11}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM12	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM12EN,
+		Device:		stm32.TIM12,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PB14, AF9_CAN1_CAN2_TIM12_13_14}, {PH6, AF9_CAN1_CAN2_TIM12_13_14}}},
+			TimerChannel{Pins: []PinFunction{{PB15, AF9_CAN1_CAN2_TIM12_13_14}, {PH9, AF9_CAN1_CAN2_TIM12_13_14}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM13	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM13EN,
+		Device:		stm32.TIM13,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA6, AF9_CAN1_CAN2_TIM12_13_14}, {PF8, AF9_CAN1_CAN2_TIM12_13_14}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM14	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR,
+		EnableFlag:	stm32.RCC_APB1ENR_TIM14EN,
+		Device:		stm32.TIM14,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{{PA7, AF9_CAN1_CAN2_TIM12_13_14}, {PF9, AF9_CAN1_CAN2_TIM12_13_14}}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+)
+```
+
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself.
+
+The length of the device ID for STM32 is 12 bytes (96 bits).
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of cryptographically secure random data
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC1.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(ADCConfig)
+```
+
+Configure configures an ADC pin to be able to read analog data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin in the range 0..0xffff.
+TODO: DMA based implementation.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type ChannelCallback
+
+```go
+type ChannelCallback func(channel uint8)
+```
+
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*stm32.I2C_Type
+	AltFuncSelector	uint8
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the STM32 I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+	DutyCycle	uint8
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration
+
+
+### func (Pin) ConfigureAltFunc
+
+```go
+func (p Pin) ConfigureAltFunc(config PinConfig, altFunc uint8)
+```
+
+Configure this pin with the given configuration including alternate
+
+	function mapping if necessary.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+PortMaskClear returns the register and mask to disable a given port. This can
+be used to implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+PortMaskSet returns the register and mask to enable a given GPIO pin. This
+can be used to implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetAltFunc
+
+```go
+func (p Pin) SetAltFunc(af uint8)
+```
+
+SetAltFunc maps the given alternative function to the I/O pin
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+---------- General pin operations ----------
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinFunction
+
+```go
+type PinFunction struct {
+	Pin	Pin
+	AltFunc	uint8
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus		*stm32.SPI_Type
+	AltFuncSelector	uint8
+}
+```
+
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the STM32 SPI1 interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type TIM
+
+```go
+type TIM struct {
+	EnableRegister	*volatile.Register32
+	EnableFlag	uint32
+	Device		*stm32.TIM_Type
+	Channels	[4]TimerChannel
+	UpInterrupt	interrupt.Interrupt
+	OCInterrupt	interrupt.Interrupt
+
+	wraparoundCallback	TimerCallback
+	channelCallbacks	[4]ChannelCallback
+
+	busFreq	uint64
+}
+```
+
+
+
+
+### func (*TIM) Channel
+
+```go
+func (t *TIM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*TIM) Configure
+
+```go
+func (t *TIM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+
+
+### func (*TIM) Count
+
+```go
+func (t *TIM) Count() uint32
+```
+
+
+
+### func (*TIM) Set
+
+```go
+func (t *TIM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	t.Set(ch, t.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*TIM) SetInverting
+
+```go
+func (t *TIM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TIM) SetMatchInterrupt
+
+```go
+func (t *TIM) SetMatchInterrupt(channel uint8, callback ChannelCallback) error
+```
+
+Sets a callback to be called when a channel reaches it's set-point.
+
+For example, if `t.Set(ch, t.Top() / 4)` is used then the callback will
+be called every quarter-period of the timer's base Period.
+
+
+### func (*TIM) SetPeriod
+
+```go
+func (t *TIM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TIM) SetWraparoundInterrupt
+
+```go
+func (t *TIM) SetWraparoundInterrupt(callback TimerCallback) error
+```
+
+SetWraparoundInterrupt configures a callback to be called each
+time the timer 'wraps-around'.
+
+For example, if `Configure(PWMConfig{Period:1000000})` is used,
+to set the timer period to 1ms, this callback will be called every
+1ms.
+
+
+### func (*TIM) Top
+
+```go
+func (t *TIM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+### func (*TIM) Unset
+
+```go
+func (t *TIM) Unset(channel uint8)
+```
+
+Unset disables a channel, including any configured interrupts.
+
+
+
+
+## type TimerCallback
+
+```go
+type TimerCallback func()
+```
+
+
+
+
+
+
+## type TimerChannel
+
+```go
+type TimerChannel struct {
+	Pins []PinFunction
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer			*RingBuffer
+	Bus			*stm32.USART_Type
+	Interrupt		interrupt.Interrupt
+	TxAltFuncSelector	uint8
+	RxAltFuncSelector	uint8
+
+	// Registers specific to the chip
+	rxReg		*volatile.Register32
+	txReg		*volatile.Register32
+	statusReg	*volatile.Register32
+	txEmptyFlag	uint32
+}
+```
+
+UART representation
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART. Defer to chip-specific
+routines for calculation
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/swan.md b/content/docs/reference/microcontrollers/machine/swan.md
new file mode 100644
index 00000000..298231b9
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/swan.md
@@ -0,0 +1,1568 @@
+
+---
+title: swan
+---
+
+
+## Constants
+
+```go
+const (
+	// LED on the SWAN
+	LED	= PE2
+
+	// UART pins
+	//    PA9 and PA10 are connected to the SWAN Tx/Rx
+	UART_TX_PIN	= PA9
+	UART_RX_PIN	= PA10
+
+	// I2C pins
+	//    PB6 is SCL
+	//    PB7 is SDA
+	I2C0_SCL_PIN	= PB6
+	I2C0_SDA_PIN	= PB7
+
+	// SPI pins
+	SPI1_SCK_PIN	= PD1
+	SPI1_SDI_PIN	= PB14
+	SPI1_SDO_PIN	= PB15
+	SPI0_SCK_PIN	= SPI1_SCK_PIN
+	SPI0_SDI_PIN	= SPI1_SDI_PIN
+	SPI0_SDO_PIN	= SPI1_SDO_PIN
+)
+```
+
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinRising	PinChange	= 1 << iota
+	PinFalling
+	PinToggle	= PinRising | PinFalling
+)
+```
+
+
+
+```go
+const (
+	MAX_NBYTE_SIZE	= 255
+
+	// 100ms delay = 100e6ns / 16ns
+	// In runtime_stm32_timers.go, tick is fixed at 16ns per tick
+	TIMEOUT_TICKS	= 100e6 / 16
+
+	I2C_NO_STARTSTOP		= 0x0
+	I2C_GENERATE_START_WRITE	= 0x80000000 | stm32.I2C_CR2_START
+	I2C_GENERATE_START_READ		= 0x80000000 | stm32.I2C_CR2_START | stm32.I2C_CR2_RD_WRN
+	I2C_GENERATE_STOP		= 0x80000000 | stm32.I2C_CR2_STOP
+)
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (32.768s)
+	//
+	// Timeout is based on 12-bit counter with /256 divider on
+	// 32.768kHz clock.  See 21.3.3 of RM0090 for table.
+	WatchdogMaxTimeout = ((0xfff + 1) * 256 * 1024) / 32768
+)
+```
+
+
+
+```go
+const (
+	// Mode Flag
+	PinOutput		PinMode	= 0
+	PinInput		PinMode	= PinInputFloating
+	PinInputFloating	PinMode	= 1
+	PinInputPulldown	PinMode	= 2
+	PinInputPullup		PinMode	= 3
+
+	// for UART
+	PinModeUARTTX	PinMode	= 4
+	PinModeUARTRX	PinMode	= 5
+
+	// for I2C
+	PinModeI2CSCL	PinMode	= 6
+	PinModeI2CSDA	PinMode	= 7
+
+	// for SPI
+	PinModeSPICLK	PinMode	= 8
+	PinModeSPISDO	PinMode	= 9
+	PinModeSPISDI	PinMode	= 10
+
+	// for analog/ADC
+	PinInputAnalog	PinMode	= 11
+
+	// for PWM
+	PinModePWMOutput	PinMode	= 12
+)
+```
+
+
+
+```go
+const RNG_MAX_READ_RETRIES = 1000
+```
+
+
+
+```go
+const PWM_MODE1 = 0x6
+```
+
+
+
+```go
+const (
+	AF0_SYSTEM		= 0
+	AF1_TIM1_2_LPTIM1	= 1
+	AF2_TIM1_2		= 2
+	AF3_USART2		= 3
+	AF4_I2C1_2_3		= 4
+	AF5_SPI1_2		= 5
+	AF6_SPI3		= 6
+	AF7_USART1_2_3		= 7
+	AF8_LPUART1		= 8
+	AF9_CAN1_TSC		= 9
+	AF10_USB_QUADSPI	= 10
+	AF12_COMP1_2_SWPMI1	= 12
+	AF13_SAI1		= 13
+	AF14_TIM2_15_16_LPTIM2	= 14
+	AF15_EVENTOUT		= 15
+)
+```
+
+
+
+```go
+const (
+	PA0	= portA + 0
+	PA1	= portA + 1
+	PA2	= portA + 2
+	PA3	= portA + 3
+	PA4	= portA + 4
+	PA5	= portA + 5
+	PA6	= portA + 6
+	PA7	= portA + 7
+	PA8	= portA + 8
+	PA9	= portA + 9
+	PA10	= portA + 10
+	PA11	= portA + 11
+	PA12	= portA + 12
+	PA13	= portA + 13
+	PA14	= portA + 14
+	PA15	= portA + 15
+
+	PB0	= portB + 0
+	PB1	= portB + 1
+	PB2	= portB + 2
+	PB3	= portB + 3
+	PB4	= portB + 4
+	PB5	= portB + 5
+	PB6	= portB + 6
+	PB7	= portB + 7
+	PB8	= portB + 8
+	PB9	= portB + 9
+	PB10	= portB + 10
+	PB11	= portB + 11
+	PB12	= portB + 12
+	PB13	= portB + 13
+	PB14	= portB + 14
+	PB15	= portB + 15
+
+	PC0	= portC + 0
+	PC1	= portC + 1
+	PC2	= portC + 2
+	PC3	= portC + 3
+	PC4	= portC + 4
+	PC5	= portC + 5
+	PC6	= portC + 6
+	PC7	= portC + 7
+	PC8	= portC + 8
+	PC9	= portC + 9
+	PC10	= portC + 10
+	PC11	= portC + 11
+	PC12	= portC + 12
+	PC13	= portC + 13
+	PC14	= portC + 14
+	PC15	= portC + 15
+
+	PD0	= portD + 0
+	PD1	= portD + 1
+	PD2	= portD + 2
+	PD3	= portD + 3
+	PD4	= portD + 4
+	PD5	= portD + 5
+	PD6	= portD + 6
+	PD7	= portD + 7
+	PD8	= portD + 8
+	PD9	= portD + 9
+	PD10	= portD + 10
+	PD11	= portD + 11
+	PD12	= portD + 12
+	PD13	= portD + 13
+	PD14	= portD + 14
+	PD15	= portD + 15
+
+	PE0	= portE + 0
+	PE1	= portE + 1
+	PE2	= portE + 2
+	PE3	= portE + 3
+	PE4	= portE + 4
+	PE5	= portE + 5
+	PE6	= portE + 6
+	PE7	= portE + 7
+	PE8	= portE + 8
+	PE9	= portE + 9
+	PE10	= portE + 10
+	PE11	= portE + 11
+	PE12	= portE + 12
+	PE13	= portE + 13
+	PE14	= portE + 14
+	PE15	= portE + 15
+)
+```
+
+
+
+```go
+const (
+	ARR_MAX	= 0x10000
+	PSC_MAX	= 0x10000
+)
+```
+
+
+
+```go
+const APB1_TIM_FREQ = 120e6	// 120MHz
+
+```
+
+Internal use: configured speed of the APB1 and APB2 timers, this should be kept
+in sync with any changes to runtime package which configures the oscillators
+and clock frequencies
+
+
+```go
+const APB2_TIM_FREQ = 120e6	// 120MHz
+
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	// USART1 is connected to the TX/RX pins
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:			NewRingBuffer(),
+		Bus:			stm32.USART1,
+		TxAltFuncSelector:	7,
+		RxAltFuncSelector:	7,
+	}
+	DefaultUART	= UART1
+
+	// I2C1 is documented, alias to I2C0 as well
+	I2C1	= &I2C{
+		Bus:			stm32.I2C1,
+		AltFuncSelector:	4,
+	}
+	I2C0	= I2C1
+
+	// SPI1 is documented, alias to SPI0 as well
+	SPI1	= &SPI{
+		Bus:			stm32.SPI2,
+		AltFuncSelector:	5,
+	}
+	SPI0	= SPI1
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	TIM1	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM1EN,
+		Device:		stm32.TIM1,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{
+				{PA8, AF1_TIM1_2_LPTIM1},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA9, AF1_TIM1_2_LPTIM1},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA10, AF1_TIM1_2_LPTIM1},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA11, AF1_TIM1_2_LPTIM1},
+			}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM2	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR1,
+		EnableFlag:	stm32.RCC_APB1ENR1_TIM2EN,
+		Device:		stm32.TIM2,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{
+				{PA0, AF1_TIM1_2_LPTIM1},
+				{PA5, AF1_TIM1_2_LPTIM1},
+				{PA15, AF1_TIM1_2_LPTIM1},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA1, AF1_TIM1_2_LPTIM1},
+				{PB3, AF1_TIM1_2_LPTIM1},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA2, AF1_TIM1_2_LPTIM1},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA3, AF1_TIM1_2_LPTIM1},
+			}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM3	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR1,
+		EnableFlag:	stm32.RCC_APB1ENR1_TIM3EN,
+		Device:		stm32.TIM3,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM6	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR1,
+		EnableFlag:	stm32.RCC_APB1ENR1_TIM6EN,
+		Device:		stm32.TIM6,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM7	= TIM{
+		EnableRegister:	&stm32.RCC.APB1ENR1,
+		EnableFlag:	stm32.RCC_APB1ENR1_TIM7EN,
+		Device:		stm32.TIM7,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB1_TIM_FREQ,
+	}
+
+	TIM15	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM15EN,
+		Device:		stm32.TIM15,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{
+				{PA2, AF14_TIM2_15_16_LPTIM2},
+			}},
+			TimerChannel{Pins: []PinFunction{
+				{PA3, AF14_TIM2_15_16_LPTIM2},
+			}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+
+	TIM16	= TIM{
+		EnableRegister:	&stm32.RCC.APB2ENR,
+		EnableFlag:	stm32.RCC_APB2ENR_TIM16EN,
+		Device:		stm32.TIM16,
+		Channels: [4]TimerChannel{
+			TimerChannel{Pins: []PinFunction{
+				{PA6, AF14_TIM2_15_16_LPTIM2},
+			}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+			TimerChannel{Pins: []PinFunction{}},
+		},
+		busFreq:	APB2_TIM_FREQ,
+	}
+)
+```
+
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself.
+
+The length of the device ID for STM32 is 12 bytes (96 bits).
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of cryptographically secure random data
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type ChannelCallback
+
+```go
+type ChannelCallback func(channel uint8)
+```
+
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*stm32.I2C_Type
+	AltFuncSelector	uint8
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration
+
+
+### func (Pin) ConfigureAltFunc
+
+```go
+func (p Pin) ConfigureAltFunc(config PinConfig, altFunc uint8)
+```
+
+Configure this pin with the given configuration including alternate
+
+	function mapping if necessary.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+PortMaskClear returns the register and mask to disable a given port. This can
+be used to implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+PortMaskSet returns the register and mask to enable a given GPIO pin. This
+can be used to implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetAltFunc
+
+```go
+func (p Pin) SetAltFunc(af uint8)
+```
+
+SetAltFunc maps the given alternative function to the I/O pin
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+---------- General pin operations ----------
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinFunction
+
+```go
+type PinFunction struct {
+	Pin	Pin
+	AltFunc	uint8
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus		*stm32.SPI_Type
+	AltFuncSelector	uint8
+}
+```
+
+SPI on the STM32Fxxx using MODER / alternate function pins
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the STM32 SPI1 interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type TIM
+
+```go
+type TIM struct {
+	EnableRegister	*volatile.Register32
+	EnableFlag	uint32
+	Device		*stm32.TIM_Type
+	Channels	[4]TimerChannel
+	UpInterrupt	interrupt.Interrupt
+	OCInterrupt	interrupt.Interrupt
+
+	wraparoundCallback	TimerCallback
+	channelCallbacks	[4]ChannelCallback
+
+	busFreq	uint64
+}
+```
+
+
+
+
+### func (*TIM) Channel
+
+```go
+func (t *TIM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*TIM) Configure
+
+```go
+func (t *TIM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+
+
+### func (*TIM) Count
+
+```go
+func (t *TIM) Count() uint32
+```
+
+
+
+### func (*TIM) Set
+
+```go
+func (t *TIM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	t.Set(ch, t.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*TIM) SetInverting
+
+```go
+func (t *TIM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TIM) SetMatchInterrupt
+
+```go
+func (t *TIM) SetMatchInterrupt(channel uint8, callback ChannelCallback) error
+```
+
+Sets a callback to be called when a channel reaches it's set-point.
+
+For example, if `t.Set(ch, t.Top() / 4)` is used then the callback will
+be called every quarter-period of the timer's base Period.
+
+
+### func (*TIM) SetPeriod
+
+```go
+func (t *TIM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TIM) SetWraparoundInterrupt
+
+```go
+func (t *TIM) SetWraparoundInterrupt(callback TimerCallback) error
+```
+
+SetWraparoundInterrupt configures a callback to be called each
+time the timer 'wraps-around'.
+
+For example, if `Configure(PWMConfig{Period:1000000})` is used,
+to set the timer period to 1ms, this callback will be called every
+1ms.
+
+
+### func (*TIM) Top
+
+```go
+func (t *TIM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+### func (*TIM) Unset
+
+```go
+func (t *TIM) Unset(channel uint8)
+```
+
+Unset disables a channel, including any configured interrupts.
+
+
+
+
+## type TimerCallback
+
+```go
+type TimerCallback func()
+```
+
+
+
+
+
+
+## type TimerChannel
+
+```go
+type TimerChannel struct {
+	Pins []PinFunction
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer			*RingBuffer
+	Bus			*stm32.USART_Type
+	Interrupt		interrupt.Interrupt
+	TxAltFuncSelector	uint8
+	RxAltFuncSelector	uint8
+
+	// Registers specific to the chip
+	rxReg		*volatile.Register32
+	txReg		*volatile.Register32
+	statusReg	*volatile.Register32
+	txEmptyFlag	uint32
+}
+```
+
+UART representation
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART. Defer to chip-specific
+routines for calculation
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/microcontrollers/machine/teensy36.md b/content/docs/reference/microcontrollers/machine/teensy36.md
similarity index 57%
rename from content/microcontrollers/machine/teensy36.md
rename to content/docs/reference/microcontrollers/machine/teensy36.md
index dd364c40..ca00658b 100644
--- a/content/microcontrollers/machine/teensy36.md
+++ b/content/docs/reference/microcontrollers/machine/teensy36.md
@@ -6,13 +6,6 @@ title: teensy36
 
 ## Constants
 
-```go
-const LED = PC05
-```
-
-LED on the Teensy
-
-
 ```go
 const (
 	D00	= PB16
@@ -85,6 +78,35 @@ const (
 digital IO
 
 
+```go
+const LED = PC05
+```
+
+LED on the Teensy
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
 ```go
 const NoPin = Pin(0xff)
 ```
@@ -96,8 +118,8 @@ of the pins in a peripheral unconfigured (if supported by the hardware).
 ```go
 const (
 	PinInput	PinMode	= iota
-	PinInputPullUp
-	PinInputPullDown
+	PinInputPullup
+	PinInputPulldown
 	PinOutput
 	PinOutputOpenDrain
 	PinDisable
@@ -106,6 +128,16 @@ const (
 
 
 
+```go
+const (
+	PinInputPullUp		= PinInputPullup
+	PinInputPullDown	= PinInputPulldown
+)
+```
+
+Deprecated: use PinInputPullup and PinInputPulldown instead.
+
+
 ```go
 const (
 	PA00	Pin	= iota
@@ -260,6 +292,24 @@ const (
 
 
 
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
 
 
 
@@ -267,18 +317,27 @@ const (
 
 ```go
 var (
-	TeensyUART1	= &UART0
-	TeensyUART2	= &UART1
-	TeensyUART3	= &UART2
-	TeensyUART4	= &UART3
-	TeensyUART5	= &UART4
+	TeensyUART1	= UART0
+	TeensyUART2	= UART1
+	TeensyUART3	= UART2
+	TeensyUART4	= UART3
+	TeensyUART5	= UART4
 )
 ```
 
 
 
+```go
+var DefaultUART = UART0
+```
+
+
+
 ```go
 var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
 	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
 	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
 	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
@@ -299,45 +358,56 @@ var (
 
 
 ```go
-var UART0 = UART{UART_Type: nxp.UART0, SCGC: &nxp.SIM.SCGC4, SCGCMask: nxp.SIM_SCGC4_UART0, DefaultRX: defaultUART0RX, DefaultTX: defaultUART0TX}
+var (
+	UART0	= &_UART0
+	UART1	= &_UART1
+	UART2	= &_UART2
+	UART3	= &_UART3
+	UART4	= &_UART4
+	_UART0	= UART{UART_Type: nxp.UART0, SCGC: &nxp.SIM.SCGC4, SCGCMask: nxp.SIM_SCGC4_UART0, DefaultRX: defaultUART0RX, DefaultTX: defaultUART0TX}
+	_UART1	= UART{UART_Type: nxp.UART1, SCGC: &nxp.SIM.SCGC4, SCGCMask: nxp.SIM_SCGC4_UART1, DefaultRX: defaultUART1RX, DefaultTX: defaultUART1TX}
+	_UART2	= UART{UART_Type: nxp.UART2, SCGC: &nxp.SIM.SCGC4, SCGCMask: nxp.SIM_SCGC4_UART2, DefaultRX: defaultUART2RX, DefaultTX: defaultUART2TX}
+	_UART3	= UART{UART_Type: nxp.UART3, SCGC: &nxp.SIM.SCGC4, SCGCMask: nxp.SIM_SCGC4_UART3, DefaultRX: defaultUART3RX, DefaultTX: defaultUART3TX}
+	_UART4	= UART{UART_Type: nxp.UART4, SCGC: &nxp.SIM.SCGC1, SCGCMask: nxp.SIM_SCGC1_UART4, DefaultRX: defaultUART4RX, DefaultTX: defaultUART4TX}
+)
 ```
 
 
 
 ```go
-var UART1 = UART{UART_Type: nxp.UART1, SCGC: &nxp.SIM.SCGC4, SCGCMask: nxp.SIM_SCGC4_UART1, DefaultRX: defaultUART1RX, DefaultTX: defaultUART1TX}
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
 ```
 
 
 
 ```go
-var UART2 = UART{UART_Type: nxp.UART2, SCGC: &nxp.SIM.SCGC4, SCGCMask: nxp.SIM_SCGC4_UART2, DefaultRX: defaultUART2RX, DefaultTX: defaultUART2TX}
+var Serial = DefaultUART
 ```
 
+Serial is implemented via the default (usually the first) UART on the chip.
+
 
 
-```go
-var UART3 = UART{UART_Type: nxp.UART3, SCGC: &nxp.SIM.SCGC4, SCGCMask: nxp.SIM_SCGC4_UART3, DefaultRX: defaultUART3RX, DefaultTX: defaultUART3TX}
-```
 
 
+### func CPUFrequency
 
 ```go
-var UART4 = UART{UART_Type: nxp.UART4, SCGC: &nxp.SIM.SCGC1, SCGCMask: nxp.SIM_SCGC1_UART4, DefaultRX: defaultUART4RX, DefaultTX: defaultUART4TX}
+func CPUFrequency() uint32
 ```
 
+CPUFrequency returns the frequency of the ARM core clock (180MHz)
 
 
-
-
-
-### func CPUFrequency
+### func CPUReset
 
 ```go
-func CPUFrequency() uint32
+func CPUReset()
 ```
 
-CPUFrequency returns the frequency of the ARM core clock (180MHz)
+CPUReset performs a hard system reset.
 
 
 ### func ClockFrequency
@@ -349,6 +419,14 @@ func ClockFrequency() uint32
 ClockFrequency returns the frequency of the external oscillator (16MHz)
 
 
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
 ### func NewRingBuffer
 
 ```go
@@ -393,6 +471,24 @@ type ADC struct {
 
 
 
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
 ## type FastPin
 
 ```go
@@ -451,11 +547,74 @@ func (p FastPin) Write(v bool)
 
 
 
-## type PWM
+## type NullSerial
 
 ```go
-type PWM struct {
-	Pin Pin
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
 }
 ```
 
@@ -464,6 +623,29 @@ type PWM struct {
 
 
 
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
 ## type Pin
 
 ```go
@@ -562,6 +744,9 @@ type PinConfig struct {
 type PinMode uint8
 ```
 
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
 
 
 
@@ -645,10 +830,10 @@ type UART struct {
 
 
 
-### func (UART) Buffered
+### func (*UART) Buffered
 
 ```go
-func (uart UART) Buffered() int
+func (uart *UART) Buffered() int
 ```
 
 Buffered returns the number of bytes currently stored in the RX buffer.
@@ -679,51 +864,53 @@ func (u *UART) Flush()
 
 
 
-### func (UART) Read
+### func (*UART) Read
 
 ```go
-func (uart UART) Read(data []byte) (n int, err error)
+func (uart *UART) Read(data []byte) (n int, err error)
 ```
 
 Read from the RX buffer.
 
 
-### func (UART) ReadByte
+### func (*UART) ReadByte
 
 ```go
-func (uart UART) ReadByte() (byte, error)
+func (uart *UART) ReadByte() (byte, error)
 ```
 
 ReadByte reads a single byte from the RX buffer.
 If there is no data in the buffer, returns an error.
 
 
-### func (UART) Receive
+### func (*UART) Receive
 
 ```go
-func (uart UART) Receive(data byte)
+func (uart *UART) Receive(data byte)
 ```
 
 Receive handles adding data to the UART's data buffer.
 Usually called by the IRQ handler for a machine.
 
 
-### func (UART) Write
+### func (*UART) Write
 
 ```go
-func (uart UART) Write(data []byte) (n int, err error)
+func (uart *UART) Write(data []byte) (n int, err error)
 ```
 
-Write data to the UART.
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
 
 
 ### func (*UART) WriteByte
 
 ```go
-func (u *UART) WriteByte(c byte) error
+func (uart *UART) WriteByte(c byte) error
 ```
 
-WriteByte writes a byte of data to the UART.
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
 
 
 
@@ -735,9 +922,26 @@ type UARTConfig struct {
 	BaudRate	uint32
 	TX		Pin
 	RX		Pin
+	RTS		Pin
+	CTS		Pin
 }
 ```
 
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
 
 
 
diff --git a/content/microcontrollers/machine/teensy40.md b/content/docs/reference/microcontrollers/machine/teensy40.md
similarity index 75%
rename from content/microcontrollers/machine/teensy40.md
rename to content/docs/reference/microcontrollers/machine/teensy40.md
index b4c0f4d3..85992e5d 100644
--- a/content/microcontrollers/machine/teensy40.md
+++ b/content/docs/reference/microcontrollers/machine/teensy40.md
@@ -158,6 +158,8 @@ const (
 )
 ```
 
+#==================================================================#
+|                               SPI                                |
 #===========#==========#===============#===========================#
 | Interface | Hardware |  Clock(Freq)  | SDI/SDO/SCK/CS  :   Alt   |
 #===========#==========#===============#=================-=========#
@@ -191,6 +193,71 @@ const (
 #===========#==========#=============#=========-=====#
 
 
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
 ```go
 const NoPin = Pin(0xff)
 ```
@@ -203,8 +270,8 @@ of the pins in a peripheral unconfigured (if supported by the hardware).
 const (
 	// GPIO
 	PinInput	PinMode	= iota
-	PinInputPullUp
-	PinInputPullDown
+	PinInputPullup
+	PinInputPulldown
 	PinOutput
 	PinOutputOpenDrain
 	PinDisable
@@ -232,9 +299,17 @@ const (
 
 ```go
 const (
-	PinLow	PinChange	= iota
-	PinHigh
-	PinRising
+	PinInputPullUp		= PinInputPullup
+	PinInputPullDown	= PinInputPulldown
+)
+```
+
+Deprecated: use PinInputPullup and PinInputPulldown instead.
+
+
+```go
+const (
+	PinRising	PinChange	= iota + 2
 	PinFalling
 	PinToggle
 )
@@ -382,6 +457,36 @@ const (
 
 
 
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
 
 
 
@@ -389,9 +494,20 @@ const (
 
 ```go
 var (
-	UART1	= UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	nxp.LPUART6,
+	DefaultUART = UART1
+)
+```
+
+Default peripherals
+
+
+```go
+var (
+	UART1	= &_UART1
+	_UART1	= UART{
+		Bus:		nxp.LPUART6,
+		Buffer:		NewRingBuffer(),
+		txBuffer:	NewRingBuffer(),
 		muxRX: muxSelect{
 			mux:	nxp.IOMUXC_LPUART6_RX_SELECT_INPUT_DAISY_GPIO_AD_B0_03_ALT2,
 			sel:	&nxp.IOMUXC.LPUART6_RX_SELECT_INPUT,
@@ -401,9 +517,11 @@ var (
 			sel:	&nxp.IOMUXC.LPUART6_TX_SELECT_INPUT,
 		},
 	}
-	UART2	= UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	nxp.LPUART4,
+	UART2	= &_UART2
+	_UART2	= UART{
+		Bus:		nxp.LPUART4,
+		Buffer:		NewRingBuffer(),
+		txBuffer:	NewRingBuffer(),
 		muxRX: muxSelect{
 			mux:	nxp.IOMUXC_LPUART4_RX_SELECT_INPUT_DAISY_GPIO_B1_01_ALT2,
 			sel:	&nxp.IOMUXC.LPUART4_RX_SELECT_INPUT,
@@ -413,9 +531,11 @@ var (
 			sel:	&nxp.IOMUXC.LPUART4_TX_SELECT_INPUT,
 		},
 	}
-	UART3	= UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	nxp.LPUART2,
+	UART3	= &_UART3
+	_UART3	= UART{
+		Bus:		nxp.LPUART2,
+		Buffer:		NewRingBuffer(),
+		txBuffer:	NewRingBuffer(),
 		muxRX: muxSelect{
 			mux:	nxp.IOMUXC_LPUART2_RX_SELECT_INPUT_DAISY_GPIO_AD_B1_03_ALT2,
 			sel:	&nxp.IOMUXC.LPUART2_RX_SELECT_INPUT,
@@ -425,9 +545,11 @@ var (
 			sel:	&nxp.IOMUXC.LPUART2_TX_SELECT_INPUT,
 		},
 	}
-	UART4	= UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	nxp.LPUART3,
+	UART4	= &_UART4
+	_UART4	= UART{
+		Bus:		nxp.LPUART3,
+		Buffer:		NewRingBuffer(),
+		txBuffer:	NewRingBuffer(),
 		muxRX: muxSelect{
 			mux:	nxp.IOMUXC_LPUART3_RX_SELECT_INPUT_DAISY_GPIO_AD_B1_07_ALT2,
 			sel:	&nxp.IOMUXC.LPUART3_RX_SELECT_INPUT,
@@ -437,9 +559,11 @@ var (
 			sel:	&nxp.IOMUXC.LPUART3_TX_SELECT_INPUT,
 		},
 	}
-	UART5	= UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	nxp.LPUART8,
+	UART5	= &_UART5
+	_UART5	= UART{
+		Bus:		nxp.LPUART8,
+		Buffer:		NewRingBuffer(),
+		txBuffer:	NewRingBuffer(),
 		muxRX: muxSelect{
 			mux:	nxp.IOMUXC_LPUART8_RX_SELECT_INPUT_DAISY_GPIO_AD_B1_11_ALT2,
 			sel:	&nxp.IOMUXC.LPUART8_RX_SELECT_INPUT,
@@ -449,13 +573,17 @@ var (
 			sel:	&nxp.IOMUXC.LPUART8_TX_SELECT_INPUT,
 		},
 	}
-	UART6	= UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	nxp.LPUART1,
+	UART6	= &_UART6
+	_UART6	= UART{
+		Bus:		nxp.LPUART1,
+		Buffer:		NewRingBuffer(),
+		txBuffer:	NewRingBuffer(),
 	}
-	UART7	= UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	nxp.LPUART7,
+	UART7	= &_UART7
+	_UART7	= UART{
+		Bus:		nxp.LPUART7,
+		Buffer:		NewRingBuffer(),
+		txBuffer:	NewRingBuffer(),
 		muxRX: muxSelect{
 			mux:	nxp.IOMUXC_LPUART7_RX_SELECT_INPUT_DAISY_GPIO_EMC_32_ALT2,
 			sel:	&nxp.IOMUXC.LPUART7_RX_SELECT_INPUT,
@@ -472,6 +600,124 @@ var (
 
 ```go
 var (
+	SPI0	= SPI1	// SPI0 is an alias of SPI1 (LPSPI4)
+	SPI1	= &SPI{
+		Bus:	nxp.LPSPI4,
+		muxSDI: muxSelect{
+			mux:	nxp.IOMUXC_LPSPI4_SDI_SELECT_INPUT_DAISY_GPIO_B0_01_ALT3,
+			sel:	&nxp.IOMUXC.LPSPI4_SDI_SELECT_INPUT,
+		},
+		muxSDO: muxSelect{
+			mux:	nxp.IOMUXC_LPSPI4_SDO_SELECT_INPUT_DAISY_GPIO_B0_02_ALT3,
+			sel:	&nxp.IOMUXC.LPSPI4_SDO_SELECT_INPUT,
+		},
+		muxSCK: muxSelect{
+			mux:	nxp.IOMUXC_LPSPI4_SCK_SELECT_INPUT_DAISY_GPIO_B0_03_ALT3,
+			sel:	&nxp.IOMUXC.LPSPI4_SCK_SELECT_INPUT,
+		},
+		muxCS: muxSelect{
+			mux:	nxp.IOMUXC_LPSPI4_PCS0_SELECT_INPUT_DAISY_GPIO_B0_00_ALT3,
+			sel:	&nxp.IOMUXC.LPSPI4_PCS0_SELECT_INPUT,
+		},
+	}
+	SPI2	= &SPI{
+		Bus:	nxp.LPSPI3,
+		muxSDI: muxSelect{
+			mux:	nxp.IOMUXC_LPSPI3_SDI_SELECT_INPUT_DAISY_GPIO_AD_B0_02_ALT7,
+			sel:	&nxp.IOMUXC.LPSPI3_SDI_SELECT_INPUT,
+		},
+		muxSDO: muxSelect{
+			mux:	nxp.IOMUXC_LPSPI3_SDO_SELECT_INPUT_DAISY_GPIO_AD_B1_14_ALT2,
+			sel:	&nxp.IOMUXC.LPSPI3_SDO_SELECT_INPUT,
+		},
+		muxSCK: muxSelect{
+			mux:	nxp.IOMUXC_LPSPI3_SCK_SELECT_INPUT_DAISY_GPIO_AD_B1_15,
+			sel:	&nxp.IOMUXC.LPSPI3_SCK_SELECT_INPUT,
+		},
+		muxCS: muxSelect{
+			mux:	nxp.IOMUXC_LPSPI3_PCS0_SELECT_INPUT_DAISY_GPIO_AD_B0_03_ALT7,
+			sel:	&nxp.IOMUXC.LPSPI3_PCS0_SELECT_INPUT,
+		},
+	}
+	SPI3	= &SPI{
+		Bus:	nxp.LPSPI1,
+		muxSDI: muxSelect{
+			mux:	nxp.IOMUXC_LPSPI1_SDI_SELECT_INPUT_DAISY_GPIO_SD_B0_03_ALT4,
+			sel:	&nxp.IOMUXC.LPSPI1_SDI_SELECT_INPUT,
+		},
+		muxSDO: muxSelect{
+			mux:	nxp.IOMUXC_LPSPI1_SDO_SELECT_INPUT_DAISY_GPIO_SD_B0_02_ALT4,
+			sel:	&nxp.IOMUXC.LPSPI1_SDO_SELECT_INPUT,
+		},
+		muxSCK: muxSelect{
+			mux:	nxp.IOMUXC_LPSPI1_SCK_SELECT_INPUT_DAISY_GPIO_SD_B0_00_ALT4,
+			sel:	&nxp.IOMUXC.LPSPI1_SCK_SELECT_INPUT,
+		},
+		muxCS: muxSelect{
+			mux:	nxp.IOMUXC_LPSPI1_PCS0_SELECT_INPUT_DAISY_GPIO_SD_B0_01_ALT4,
+			sel:	&nxp.IOMUXC.LPSPI1_PCS0_SELECT_INPUT,
+		},
+	}
+)
+```
+
+
+
+```go
+var (
+	I2C0	= I2C1	// I2C0 is an alias for I2C1 (LPI2C1)
+	I2C1	= &_I2C1
+	_I2C1	= I2C{
+		Bus:	nxp.LPI2C1,
+		sda:	I2C1_SDA_PIN,
+		scl:	I2C1_SCL_PIN,
+		muxSDA: muxSelect{
+			mux:	nxp.IOMUXC_LPI2C1_SDA_SELECT_INPUT_DAISY_GPIO_AD_B1_01_ALT3,
+			sel:	&nxp.IOMUXC.LPI2C1_SDA_SELECT_INPUT,
+		},
+		muxSCL: muxSelect{
+			mux:	nxp.IOMUXC_LPI2C1_SCL_SELECT_INPUT_DAISY_GPIO_AD_B1_00_ALT3,
+			sel:	&nxp.IOMUXC.LPI2C1_SCL_SELECT_INPUT,
+		},
+	}
+	I2C2	= &_I2C2
+	_I2C2	= I2C{
+		Bus:	nxp.LPI2C3,
+		sda:	I2C2_SDA_PIN,
+		scl:	I2C2_SCL_PIN,
+		muxSDA: muxSelect{
+			mux:	nxp.IOMUXC_LPI2C3_SDA_SELECT_INPUT_DAISY_GPIO_AD_B1_06_ALT1,
+			sel:	&nxp.IOMUXC.LPI2C3_SDA_SELECT_INPUT,
+		},
+		muxSCL: muxSelect{
+			mux:	nxp.IOMUXC_LPI2C3_SCL_SELECT_INPUT_DAISY_GPIO_AD_B1_07_ALT1,
+			sel:	&nxp.IOMUXC.LPI2C3_SCL_SELECT_INPUT,
+		},
+	}
+	I2C3	= &_I2C3
+	_I2C3	= I2C{
+		Bus:	nxp.LPI2C4,
+		sda:	I2C3_SDA_PIN,
+		scl:	I2C3_SCL_PIN,
+		muxSDA: muxSelect{
+			mux:	nxp.IOMUXC_LPI2C4_SDA_SELECT_INPUT_DAISY_GPIO_AD_B0_13_ALT0,
+			sel:	&nxp.IOMUXC.LPI2C4_SDA_SELECT_INPUT,
+		},
+		muxSCL: muxSelect{
+			mux:	nxp.IOMUXC_LPI2C4_SCL_SELECT_INPUT_DAISY_GPIO_AD_B0_12_ALT0,
+			sel:	&nxp.IOMUXC.LPI2C4_SCL_SELECT_INPUT,
+		},
+	}
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
 	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
 	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
 	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
@@ -482,6 +728,30 @@ var (
 
 
 
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
 
 
 
@@ -493,6 +763,32 @@ func CPUFrequency() uint32
 
 
 
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC is not used by this machine. Use `(ADC).Configure()`.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
 ### func NewRingBuffer
 
 ```go
@@ -515,16 +811,288 @@ type ADC struct {
 
 
 
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig)
+```
+
+Configure initializes the receiver's ADC peripheral and pin for analog input.
 
 
-## type PWM
+### func (ADC) Get
 
 ```go
-type PWM struct {
-	Pin Pin
+func (a ADC) Get() uint16
+```
+
+Get performs a single ADC conversion, returning a 16-bit unsigned integer.
+The value returned will be scaled (uniformly distributed) if necessary so
+that it is always in the range [0..65535], regardless of the ADC's configured
+bit size (resolution).
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
 }
 ```
 
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*nxp.LPI2C_Type
+
+	// these pins are initialized by each global I2C variable declared in the
+	// board_teensy4x.go file according to the board manufacturer's default pin
+	// mapping. they can be overridden with the I2CConfig argument given to
+	// (*I2C) Configure(I2CConfig).
+	sda, scl	Pin
+
+	// these hold the input selector ("daisy chain") values that select which pins
+	// are connected to the LPI2C device, and should be defined where the I2C
+	// instance is declared (e.g., in the board definition). see the godoc
+	// comments on type muxSelect for more details.
+	muxSDA, muxSCL	muxSelect
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup an I2C interface for transmit/receive.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (I2C) ReadRegisterEx
+
+```go
+func (i2c I2C) ReadRegisterEx(address uint8, register uint8, data []byte) error
+```
+
+ReadRegisterEx transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (I2C) SetBaudRate
+
+```go
+func (i2c I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (I2C) Tx
+
+```go
+func (i2c I2C) Tx(addr uint16, w, r []byte) error
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+### func (I2C) WriteRegisterEx
+
+```go
+func (i2c I2C) WriteRegisterEx(address uint8, register uint8, data []byte) error
+```
+
+WriteRegisterEx transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SDA		Pin
+	SCL		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
 
 
 
@@ -648,6 +1216,9 @@ type PinConfig struct {
 type PinMode uint8
 ```
 
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
 
 
 
@@ -708,6 +1279,97 @@ Used returns how many bytes in buffer have been used.
 
 
 
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*nxp.LPSPI_Type
+
+	// these hold the input selector ("daisy chain") values that select which pins
+	// are connected to the LPSPI device, and should be defined where the SPI
+	// instance is declared (e.g., in the board definition). see the godoc
+	// comments on type muxSelect for more details.
+	muxSDI, muxSDO, muxSCK, muxCS	muxSelect
+
+	// these are copied from SPIConfig, during (*SPI).Configure(SPIConfig), and
+	// should be considered read-only for internal reference (i.e., modifying them
+	// will have no desirable effect).
+	sdi, sdo, sck, cs	Pin
+	frequency		uint32
+
+	// auxiliary state data used internally
+	configured	bool
+}
+```
+
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup an SPI interface for transmit/receive.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SDI		Pin
+	SDO		Pin
+	SCK		Pin
+	CS		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
 ## type UART
 
 ```go
@@ -716,6 +1378,10 @@ type UART struct {
 	Buffer		*RingBuffer
 	Interrupt	interrupt.Interrupt
 
+	// txBuffer should be allocated globally (such as when UART is created) to
+	// prevent it being reclaimed or cleaned up prematurely.
+	txBuffer	*RingBuffer
+
 	// these hold the input selector ("daisy chain") values that select which pins
 	// are connected to the LPUART device, and should be defined where the UART
 	// instance is declared. see the godoc comments on type muxSelect for more
@@ -730,19 +1396,17 @@ type UART struct {
 
 	// auxiliary state data used internally
 	configured	bool
-	msbFirst	bool
 	transmitting	volatile.Register32
-	txBuffer	*RingBuffer
 }
 ```
 
 
 
 
-### func (UART) Buffered
+### func (*UART) Buffered
 
 ```go
-func (uart UART) Buffered() int
+func (uart *UART) Buffered() int
 ```
 
 Buffered returns the number of bytes currently stored in the RX buffer.
@@ -772,29 +1436,29 @@ interrupt is also disabled, and the RX/TX pins are reconfigured for GPIO
 input (pull-up).
 
 
-### func (UART) Read
+### func (*UART) Read
 
 ```go
-func (uart UART) Read(data []byte) (n int, err error)
+func (uart *UART) Read(data []byte) (n int, err error)
 ```
 
 Read from the RX buffer.
 
 
-### func (UART) ReadByte
+### func (*UART) ReadByte
 
 ```go
-func (uart UART) ReadByte() (byte, error)
+func (uart *UART) ReadByte() (byte, error)
 ```
 
 ReadByte reads a single byte from the RX buffer.
 If there is no data in the buffer, returns an error.
 
 
-### func (UART) Receive
+### func (*UART) Receive
 
 ```go
-func (uart UART) Receive(data byte)
+func (uart *UART) Receive(data byte)
 ```
 
 Receive handles adding data to the UART's data buffer.
@@ -811,13 +1475,14 @@ Sync blocks the calling goroutine until all data in the output buffer has
 been transmitted.
 
 
-### func (UART) Write
+### func (*UART) Write
 
 ```go
-func (uart UART) Write(data []byte) (n int, err error)
+func (uart *UART) Write(data []byte) (n int, err error)
 ```
 
-Write data to the UART.
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
 
 
 ### func (*UART) WriteByte
@@ -826,7 +1491,8 @@ Write data to the UART.
 func (uart *UART) WriteByte(c byte) error
 ```
 
-WriteByte writes a single byte of data to the UART interface.
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
 
 
 
@@ -838,9 +1504,26 @@ type UARTConfig struct {
 	BaudRate	uint32
 	TX		Pin
 	RX		Pin
+	RTS		Pin
+	CTS		Pin
 }
 ```
 
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
 
 
 
diff --git a/content/docs/reference/microcontrollers/machine/thingplus-rp2040.md b/content/docs/reference/microcontrollers/machine/thingplus-rp2040.md
new file mode 100644
index 00000000..953a89c9
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/thingplus-rp2040.md
@@ -0,0 +1,1709 @@
+
+---
+title: thingplus-rp2040
+---
+
+
+## Constants
+
+```go
+const (
+	GP0	Pin	= GPIO0	// TX
+	GP1	Pin	= GPIO1	// RX
+	GP2	Pin	= GPIO2	// SCK
+	GP3	Pin	= GPIO3	// COPI
+	GP4	Pin	= GPIO4	// CIPO
+
+	GP6	Pin	= GPIO6		// SDA
+	GP7	Pin	= GPIO7		// SCL (connected to GPIO23 as well)
+	GP8	Pin	= GPIO8		// WS2812 RGB LED
+	GP9	Pin	= GPIO9		// muSDcard DATA3 / CS
+	GP10	Pin	= GPIO10	// muSDcard DATA2
+	GP11	Pin	= GPIO11	// muSDcard DATA1
+	GP12	Pin	= GPIO12	// muSDcard DATA0 / CIPO
+
+	GP14	Pin	= GPIO14	// muSDcard CLK /SCLK
+	GP15	Pin	= GPIO15	// muSDcard CMD / COPI
+	GP16	Pin	= GPIO16	// 16
+	GP17	Pin	= GPIO17	// 17
+	GP18	Pin	= GPIO18	// 18
+	GP19	Pin	= GPIO19	// 19
+	GP20	Pin	= GPIO20	// 20
+	GP21	Pin	= GPIO21	// 21
+	GP22	Pin	= GPIO22	// 22
+	GP23	Pin	= GPIO23	// Connected to GPIO7
+	GP25	Pin	= GPIO25	// Status blue LED
+	GP26	Pin	= GPIO26	// ADC0
+	GP27	Pin	= GPIO27	// ADC1
+	GP28	Pin	= GPIO28	// ADC2
+	GP29	Pin	= GPIO29	// ADC3
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A0	= GPIO26
+	A1	= GPIO27
+	A2	= GPIO28
+	A3	= GPIO29
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	LED	= GPIO25
+	WS2812	= GPIO8
+)
+```
+
+Onboard LEDs
+
+
+```go
+const (
+	I2C0_SCL_PIN	= GPIO6	// N/A
+	I2C0_SDA_PIN	= GPIO7	// N/A
+
+	I2C1_SDA_PIN	= GPIO6
+	I2C1_SCL_PIN	= GPIO7
+
+	SDA_PIN	= I2C1_SDA_PIN
+	SCL_PIN	= I2C1_SCL_PIN
+)
+```
+
+I2C Pins.
+
+
+```go
+const (
+	// Default Serial Clock Bus 0 for SPI communications
+	SPI0_SCK_PIN	= GPIO2
+	// Default Serial Out Bus 0 for SPI communications
+	SPI0_SDO_PIN	= GPIO3	// Tx
+	// Default Serial In Bus 0 for SPI communications
+	SPI0_SDI_PIN	= GPIO4	// Rx
+
+	// Default Serial Clock Bus 1 for SPI communications to muSDcard
+	SPI1_SCK_PIN	= GPIO14
+	// Default Serial Out Bus 1 for SPI communications to muSDcard
+	SPI1_SDO_PIN	= GPIO15	// Tx
+	// Default Serial In Bus 1 for SPI communications to muSDcard
+	SPI1_SDI_PIN	= GPIO12	// Rx
+)
+```
+
+SPI default pins
+
+
+```go
+const (
+	UART0_TX_PIN	= GPIO0
+	UART0_RX_PIN	= GPIO1
+	UART_TX_PIN	= UART0_TX_PIN
+	UART_RX_PIN	= UART0_RX_PIN
+)
+```
+
+UART pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	LS_SE0	= 0b00
+	LS_J	= 0b01
+	LS_K	= 0b10
+	LS_SE1	= 0b11
+)
+```
+
+
+
+```go
+const (
+	cpuFreq			= 200 * MHz
+	_NUMBANK0_GPIOS		= 30
+	_NUMBANK0_IRQS		= 4
+	_NUMIRQ			= 32
+	rp2350ExtraReg		= 0
+	RESETS_RESET_Msk	= 0x01ffffff
+	initUnreset		= rp.RESETS_RESET_ADC |
+		rp.RESETS_RESET_RTC |
+		rp.RESETS_RESET_SPI0 |
+		rp.RESETS_RESET_SPI1 |
+		rp.RESETS_RESET_UART0 |
+		rp.RESETS_RESET_UART1 |
+		rp.RESETS_RESET_USBCTRL
+	initDontReset	= rp.RESETS_RESET_IO_QSPI |
+		rp.RESETS_RESET_PADS_QSPI |
+		rp.RESETS_RESET_PLL_USB |
+		rp.RESETS_RESET_USBCTRL |
+		rp.RESETS_RESET_SYSCFG |
+		rp.RESETS_RESET_PLL_SYS
+	padEnableMask	= rp.PADS_BANK0_GPIO0_IE_Msk |
+		rp.PADS_BANK0_GPIO0_OD_Msk
+)
+```
+
+
+
+```go
+const (
+	PinOutput	PinMode	= iota
+	PinInput
+	PinInputPulldown
+	PinInputPullup
+	PinAnalog
+	PinUART
+	PinPWM
+	PinI2C
+	PinSPI
+	PinPIO0
+	PinPIO1
+)
+```
+
+
+
+```go
+const (
+	ADC0	Pin	= GPIO26
+	ADC1	Pin	= GPIO27
+	ADC2	Pin	= GPIO28
+	ADC3	Pin	= GPIO29
+
+	thermADC	= 30
+)
+```
+
+Analog pins on RP2040.
+
+
+```go
+const (
+	// Edge falling
+	PinFalling	PinChange	= 4 << iota
+	// Edge rising
+	PinRising
+
+	PinToggle	= PinFalling | PinRising
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// GPIO pins
+	GPIO0	Pin	= 0	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO1	Pin	= 1	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO2	Pin	= 2	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO3	Pin	= 3	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO4	Pin	= 4	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO5	Pin	= 5	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO6	Pin	= 6	// peripherals: PWM3 channel A, I2C1 SDA
+	GPIO7	Pin	= 7	// peripherals: PWM3 channel B, I2C1 SCL
+	GPIO8	Pin	= 8	// peripherals: PWM4 channel A, I2C0 SDA
+	GPIO9	Pin	= 9	// peripherals: PWM4 channel B, I2C0 SCL
+	GPIO10	Pin	= 10	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO11	Pin	= 11	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO12	Pin	= 12	// peripherals: PWM6 channel A, I2C0 SDA
+	GPIO13	Pin	= 13	// peripherals: PWM6 channel B, I2C0 SCL
+	GPIO14	Pin	= 14	// peripherals: PWM7 channel A, I2C1 SDA
+	GPIO15	Pin	= 15	// peripherals: PWM7 channel B, I2C1 SCL
+	GPIO16	Pin	= 16	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO17	Pin	= 17	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO18	Pin	= 18	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO19	Pin	= 19	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO20	Pin	= 20	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO21	Pin	= 21	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO22	Pin	= 22	// peripherals: PWM3 channel A
+	GPIO23	Pin	= 23	// peripherals: PWM3 channel B
+	GPIO24	Pin	= 24	// peripherals: PWM4 channel A
+	GPIO25	Pin	= 25	// peripherals: PWM4 channel B
+	GPIO26	Pin	= 26	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO27	Pin	= 27	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO28	Pin	= 28	// peripherals: PWM6 channel A
+	GPIO29	Pin	= 29	// peripherals: PWM6 channel B
+)
+```
+
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 8.3s).
+	//
+	// Nominal 1us per watchdog tick, 24-bit counter,
+	// but due to errata two ticks consumed per 1us.
+	// See: Errata RP2040-E1
+	WatchdogMaxTimeout = (rp.WATCHDOG_LOAD_LOAD_Msk / 1000) / 2
+)
+```
+
+
+
+```go
+const XOSC_STARTUP_DELAY_MULTIPLIER = 64
+```
+
+On some boards, the XOSC can take longer than usual to stabilize. On such
+boards, this is needed to avoid a hard fault on boot/reset. Refer to
+PICO_XOSC_STARTUP_DELAY_MULTIPLIER in the Pico SDK for additional details.
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	UART0	= &_UART0
+	_UART0	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART0,
+	}
+
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART1,
+	}
+)
+```
+
+UART on the RP2040
+
+
+```go
+var RTC = (*rtcType)(unsafe.Pointer(rp.RTC))
+```
+
+
+
+```go
+var (
+	ErrRtcDelayTooSmall	= errors.New("RTC interrupt deplay is too small, shall be at least 1 second")
+	ErrRtcDelayTooLarge	= errors.New("RTC interrupt deplay is too large, shall be no more than 1 day")
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	I2C0	= &_I2C0
+	_I2C0	= I2C{
+		Bus: rp.I2C0,
+	}
+	I2C1	= &_I2C1
+	_I2C1	= I2C{
+		Bus: rp.I2C1,
+	}
+)
+```
+
+I2C on the RP2040/RP2350
+
+
+```go
+var (
+	ErrBadPeriod = errors.New("period outside valid range 8ns..268ms")
+)
+```
+
+
+
+```go
+var (
+	PWM0	= getPWMGroup(0)
+	PWM1	= getPWMGroup(1)
+	PWM2	= getPWMGroup(2)
+	PWM3	= getPWMGroup(3)
+	PWM4	= getPWMGroup(4)
+	PWM5	= getPWMGroup(5)
+	PWM6	= getPWMGroup(6)
+	PWM7	= getPWMGroup(7)
+)
+```
+
+Hardware Pulse Width Modulation (PWM) API
+PWM peripherals available on RP2040. Each peripheral has 2 pins available for
+a total of 16 available PWM outputs. Some pins may not be available on some boards.
+
+The RP2040 PWM block has 8 identical slices. Each slice can drive two PWM output signals, or
+measure the frequency or duty cycle of an input signal. This gives a total of up to 16 controllable
+PWM outputs. All 30 GPIOs can be driven by the PWM block
+
+The PWM hardware functions by continuously comparing the input value to a free-running counter. This produces a
+toggling output where the amount of time spent at the high output level is proportional to the input value. The fraction of
+time spent at the high signal level is known as the duty cycle of the signal.
+
+The default behaviour of a PWM slice is to count upward until the wrap value (\ref pwm_config_set_wrap) is reached, and then
+immediately wrap to 0. PWM slices also offer a phase-correct mode, where the counter starts to count downward after
+reaching TOP, until it reaches 0 again.
+
+
+```go
+var (
+	SPI0	= &SPI{
+		Bus: rp.SPI0,
+	}
+	SPI1	= &SPI{
+		Bus: rp.SPI1,
+	}
+)
+```
+
+SPI on the RP2040
+
+
+```go
+var (
+	ErrLSBNotSupported	= errors.New("SPI LSB unsupported on PL022")
+	ErrSPITimeout		= errors.New("SPI timeout")
+	ErrSPIBaud		= errors.New("SPI baud too low or above 66.5Mhz")
+	errSPIInvalidSDI	= errors.New("invalid SPI SDI pin")
+	errSPIInvalidSDO	= errors.New("invalid SPI SDO pin")
+	errSPIInvalidSCK	= errors.New("invalid SPI SCK pin")
+)
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the RP2040.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ChipVersion
+
+```go
+func ChipVersion() uint8
+```
+
+ChipVersion returns the version of the chip. 1 is returned for B0 and B1
+chip.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func CurrentCore
+
+```go
+func CurrentCore() int
+```
+
+CurrentCore returns the core number the call was made from.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of semi-random data based on ring oscillator.
+
+Unlike some other implementations of GetRNG, these random numbers are not
+cryptographically secure and must not be used for cryptographic operations
+(nonces, etc).
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC resets the ADC peripheral.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func NumCores
+
+```go
+func NumCores() int
+```
+
+NumCores returns number of cores available on the device.
+
+
+### func PWMPeripheral
+
+```go
+func PWMPeripheral(pin Pin) (sliceNum uint8, err error)
+```
+
+Peripheral returns the RP2040 PWM peripheral which ranges from 0 to 7. Each
+PWM peripheral has 2 channels, A and B which correspond to 0 and 1 in the program.
+This number corresponds to the package's PWM0 throughout PWM7 handles
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() (millicelsius int32)
+```
+
+ReadTemperature does a one-shot sample of the internal temperature sensor and returns a milli-celsius reading.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig) error
+```
+
+Configure sets the ADC pin to analog input mode.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns a one-shot ADC sample reading.
+
+
+### func (ADC) GetADCChannel
+
+```go
+func (a ADC) GetADCChannel() (c ADCChannel, err error)
+```
+
+GetADCChannel returns the channel associated with the ADC pin.
+
+
+
+
+## type ADCChannel
+
+```go
+type ADCChannel uint8
+```
+
+ADCChannel is the ADC peripheral mux channel. 0-4.
+
+
+
+### func (ADCChannel) Configure
+
+```go
+func (c ADCChannel) Configure(config ADCConfig) error
+```
+
+Configure sets the channel's associated pin to analog input mode.
+The powered on temperature sensor increases ADC_AVDD current by approximately 40 μA.
+
+
+### func (ADCChannel) Pin
+
+```go
+func (c ADCChannel) Pin() (p Pin, err error)
+```
+
+The Pin method returns the GPIO Pin associated with the ADC mux channel, if it has one.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*rp.I2C0_Type
+	mode		I2CMode
+	txInProgress	bool
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure initializes i2c peripheral and configures I2C config's pins passed.
+Here's a list of valid SDA and SCL GPIO pins on bus I2C0 of the rp2040:
+
+	SDA: 0, 4, 8, 12, 16, 20
+	SCL: 1, 5, 9, 13, 17, 21
+
+Same as above for I2C1 bus:
+
+	SDA: 2, 6, 10, 14, 18, 26
+	SCL: 3, 7, 11, 15, 19, 27
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint16) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx performs a write and then a read transfer placing the result in
+in r.
+
+Passing a nil value for w or r skips the transfer corresponding to write
+or read, respectively.
+
+	i2c.Tx(addr, nil, r)
+
+Performs only a read transfer.
+
+	i2c.Tx(addr, w, nil)
+
+Performs only a write transfer.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	// SDA/SCL Serial Data and clock pins. Refer to datasheet to see
+	// which pins match the desired bus.
+	SDA, SCL	Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure configures the gpio pin as per mode.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get reads the pin value.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set drives the pin high if value is true else drives it low.
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+PinChange represents one or more trigger events that can happen on a given GPIO pin
+on the RP2040. ORed PinChanges are valid input to most IRQ functions.
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus *rp.SPI0_Type
+}
+```
+
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup/initialize the SPI interface.
+Default baudrate of 4MHz is used if Frequency == 0. Default
+word length (data bits) is 8.
+Below is a list of GPIO pins corresponding to SPI0 bus on the rp2040:
+
+	SI : 0, 4, 17  a.k.a RX and MISO (if rp2040 is master)
+	SO : 3, 7, 19  a.k.a TX and MOSI (if rp2040 is master)
+	SCK: 2, 6, 18
+
+SPI1 bus GPIO pins:
+
+	SI : 8, 12
+	SO : 11, 15
+	SCK: 10, 14
+
+No pin configuration is needed of SCK, SDO and SDI needed after calling Configure.
+
+
+### func (*SPI) GetBaudRate
+
+```go
+func (spi *SPI) GetBaudRate() uint32
+```
+
+
+
+### func (*SPI) PrintRegs
+
+```go
+func (spi *SPI) PrintRegs()
+```
+
+PrintRegs prints SPI's peripheral common registries current values
+
+
+### func (*SPI) SetBaudRate
+
+```go
+func (spi *SPI) SetBaudRate(br uint32) error
+```
+
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Write a single byte and read a single byte from TX/RX FIFO.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) (err error)
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+Remark: This implementation (RP2040) allows reading into buffer with a custom repeated
+value on tx.
+
+	spi.Tx([]byte{0xff}, rx) // may cause unwanted heap allocations.
+
+This form sends 0xff and puts the result into rx buffer. Useful for reading from SD cards
+which require 0xff input on SI.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	// LSB not supported on rp2040.
+	LSBFirst	bool
+	// Mode's two most LSB are CPOL and CPHA. i.e. Mode==2 (0b10) is CPOL=1, CPHA=0
+	Mode	uint8
+	// Serial clock pin
+	SCK	Pin
+	// TX or Serial Data Out (MOSI if rp2040 is master)
+	SDO	Pin
+	// RX or Serial Data In (MISO if rp2040 is master)
+	SDI	Pin
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*rp.UART0_Type
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the RP2040.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the baudrate to be used for the UART.
+
+
+### func (*UART) SetFormat
+
+```go
+func (uart *UART) SetFormat(databits, stopbits uint8, parity UARTParity) error
+```
+
+SetFormat for number of data bits, stop bits, and parity for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) ClearStallEPIn
+
+```go
+func (dev *USBDevice) ClearStallEPIn(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB IN endpoint.
+
+
+### func (*USBDevice) ClearStallEPOut
+
+```go
+func (dev *USBDevice) ClearStallEPOut(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB OUT endpoint.
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+### func (*USBDevice) SetStallEPIn
+
+```go
+func (dev *USBDevice) SetStallEPIn(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB IN endpoint.
+
+
+### func (*USBDevice) SetStallEPOut
+
+```go
+func (dev *USBDevice) SetStallEPOut(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB OUT endpoint.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/trinket-m0.md b/content/docs/reference/microcontrollers/machine/trinket-m0.md
new file mode 100644
index 00000000..6bede434
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/trinket-m0.md
@@ -0,0 +1,1738 @@
+
+---
+title: trinket-m0
+---
+
+
+## Constants
+
+```go
+const (
+	PA00	Pin	= 0	// peripherals: TCC2 channel 0, sercomI2CM1 SDA
+	PA01	Pin	= 1	// peripherals: TCC2 channel 1, sercomI2CM1 SCL
+	PA02	Pin	= 2
+	PA03	Pin	= 3
+	PA04	Pin	= 4	// peripherals: TCC0 channel 0
+	PA05	Pin	= 5	// peripherals: TCC0 channel 1
+	PA06	Pin	= 6	// peripherals: TCC1 channel 0
+	PA07	Pin	= 7	// peripherals: TCC1 channel 1
+	PA08	Pin	= 8	// peripherals: TCC0 channel 0, TCC1 channel 2, sercomI2CM0 SDA, sercomI2CM2 SDA
+	PA09	Pin	= 9	// peripherals: TCC0 channel 1, TCC1 channel 3, sercomI2CM0 SCL, sercomI2CM2 SCL
+	PA10	Pin	= 10	// peripherals: TCC1 channel 0, TCC0 channel 2
+	PA11	Pin	= 11	// peripherals: TCC1 channel 1, TCC0 channel 3
+	PA12	Pin	= 12	// peripherals: TCC2 channel 0, TCC0 channel 2, sercomI2CM2 SDA, sercomI2CM4 SDA
+	PA13	Pin	= 13	// peripherals: TCC2 channel 1, TCC0 channel 3, sercomI2CM2 SCL, sercomI2CM4 SCL
+	PA14	Pin	= 14	// peripherals: TCC0 channel 0
+	PA15	Pin	= 15	// peripherals: TCC0 channel 1
+	PA16	Pin	= 16	// peripherals: TCC2 channel 0, TCC0 channel 2, sercomI2CM1 SDA, sercomI2CM3 SDA
+	PA17	Pin	= 17	// peripherals: TCC2 channel 1, TCC0 channel 3, sercomI2CM1 SCL, sercomI2CM3 SCL
+	PA18	Pin	= 18	// peripherals: TCC0 channel 2
+	PA19	Pin	= 19	// peripherals: TCC0 channel 3
+	PA20	Pin	= 20	// peripherals: TCC0 channel 2
+	PA21	Pin	= 21	// peripherals: TCC0 channel 3
+	PA22	Pin	= 22	// peripherals: TCC0 channel 0, sercomI2CM3 SDA, sercomI2CM5 SDA
+	PA23	Pin	= 23	// peripherals: TCC0 channel 1, sercomI2CM3 SCL, sercomI2CM5 SCL
+	PA24	Pin	= 24	// peripherals: TCC1 channel 2
+	PA25	Pin	= 25	// peripherals: TCC1 channel 3
+	PA26	Pin	= 26
+	PA27	Pin	= 27
+	PA28	Pin	= 28
+	PA29	Pin	= 29
+	PA30	Pin	= 30	// peripherals: TCC1 channel 0
+	PA31	Pin	= 31	// peripherals: TCC1 channel 1
+	PB00	Pin	= 32
+	PB01	Pin	= 33
+	PB02	Pin	= 34	// peripherals: sercomI2CM5 SDA
+	PB03	Pin	= 35	// peripherals: sercomI2CM5 SCL
+	PB04	Pin	= 36
+	PB05	Pin	= 37
+	PB06	Pin	= 38
+	PB07	Pin	= 39
+	PB08	Pin	= 40	// peripherals: sercomI2CM4 SDA
+	PB09	Pin	= 41	// peripherals: sercomI2CM4 SCL
+	PB10	Pin	= 42	// peripherals: TCC0 channel 0
+	PB11	Pin	= 43	// peripherals: TCC0 channel 1
+	PB12	Pin	= 44	// peripherals: TCC0 channel 2, sercomI2CM4 SDA
+	PB13	Pin	= 45	// peripherals: TCC0 channel 3, sercomI2CM4 SCL
+	PB14	Pin	= 46
+	PB15	Pin	= 47
+	PB16	Pin	= 48	// peripherals: TCC0 channel 0, sercomI2CM5 SDA
+	PB17	Pin	= 49	// peripherals: TCC0 channel 1, sercomI2CM5 SCL
+	PB18	Pin	= 50
+	PB19	Pin	= 51
+	PB20	Pin	= 52
+	PB21	Pin	= 53
+	PB22	Pin	= 54
+	PB23	Pin	= 55
+	PB24	Pin	= 56
+	PB25	Pin	= 57
+	PB26	Pin	= 58
+	PB27	Pin	= 59
+	PB28	Pin	= 60
+	PB29	Pin	= 61
+	PB30	Pin	= 62	// peripherals: TCC0 channel 0, TCC1 channel 2, sercomI2CM5 SDA
+	PB31	Pin	= 63	// peripherals: TCC0 channel 1, TCC1 channel 3, sercomI2CM5 SCL
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	D0	= PA08	// PWM available
+	D1	= PA02
+	D2	= PA09	// PWM available
+	D3	= PA07	// PWM available / UART0 RX
+	D4	= PA06	// PWM available / UART0 TX
+	D13	= PA10	// LED
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A0	= D1
+	A1	= D2
+	A2	= D0
+	A3	= D3
+	A4	= D4
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	LED = D13
+)
+```
+
+
+
+```go
+const (
+	USBCDC_DM_PIN	= PA24
+	USBCDC_DP_PIN	= PA25
+)
+```
+
+USBCDC pins
+
+
+```go
+const (
+	UART_TX_PIN	= D4
+	UART_RX_PIN	= D3
+)
+```
+
+UART1 pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= D3
+	SPI0_SDO_PIN	= D4
+	SPI0_SDI_PIN	= D2
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	SDA_PIN	= D0	// SDA
+	SCL_PIN	= D2	// SCL
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	I2S_SCK_PIN	= PA10
+	I2S_SDO_PIN	= PA08
+	I2S_SDI_PIN	= NoPin	// TODO: figure out what this is on Trinket M0.
+	I2S_WS_PIN	= NoPin	// TODO: figure out what this is on Trinket M0.
+)
+```
+
+I2S pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const (
+	I2SModeSource	I2SMode	= iota
+	I2SModeReceiver
+	I2SModePDM
+	I2SModeSourceReceiver
+)
+```
+
+
+
+```go
+const (
+	I2StandardPhilips	I2SStandard	= iota
+	I2SStandardMSB
+	I2SStandardLSB
+)
+```
+
+
+
+```go
+const (
+	I2SClockSourceInternal	I2SClockSource	= iota
+	I2SClockSourceExternal
+)
+```
+
+
+
+```go
+const (
+	I2SDataFormatDefault	I2SDataFormat	= 0
+	I2SDataFormat8bit			= 8
+	I2SDataFormat16bit			= 16
+	I2SDataFormat24bit			= 24
+	I2SDataFormat32bit			= 32
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinAnalog	PinMode	= 1
+	PinSERCOM	PinMode	= 2
+	PinSERCOMAlt	PinMode	= 3
+	PinTimer	PinMode	= 4
+	PinTimerAlt	PinMode	= 5
+	PinCom		PinMode	= 6
+	//PinAC_CLK        PinMode = 7
+	PinDigital		PinMode	= 8
+	PinInput		PinMode	= 9
+	PinInputPullup		PinMode	= 10
+	PinOutput		PinMode	= 11
+	PinTCC			PinMode	= PinTimer
+	PinTCCAlt		PinMode	= PinTimerAlt
+	PinInputPulldown	PinMode	= 12
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
+	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
+	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (16s)
+	WatchdogMaxTimeout = (16384 * 1000) / 1024
+)
+```
+
+
+
+```go
+const (
+	// these are SAMD21 specific.
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Pos	= 0
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Mask	= 0x3FFF
+
+	usb_DEVICE_PCKSIZE_SIZE_Pos	= 28
+	usb_DEVICE_PCKSIZE_SIZE_Mask	= 0x7
+
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Pos	= 14
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Mask	= 0x3FFF
+
+	NumberOfUSBEndpoints	= 8
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var UART1 = &sercomUSART0
+```
+
+UART1 on the Trinket M0.
+
+
+```go
+var SPI0 = sercomSPIM0
+```
+
+SPI on the Trinket M0.
+
+
+```go
+var (
+	I2C0 = sercomI2CM2
+)
+```
+
+I2C on the Trinket M0.
+
+
+```go
+var (
+	DefaultUART = UART1
+)
+```
+
+
+
+```go
+var (
+	ErrInvalidSampleFrequency = errors.New("i2s: invalid sample frequency")
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var I2S0 = I2S{Bus: sam.I2S}
+```
+
+
+
+```go
+var (
+	TCC0	= (*TCC)(sam.TCC0)
+	TCC1	= (*TCC)(sam.TCC1)
+	TCC2	= (*TCC)(sam.TCC2)
+)
+```
+
+The SAM D21 has three TCC peripherals, which have PWM as one feature.
+
+
+```go
+var (
+	DAC0 = DAC{}
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the SAMD21.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+Return the current CPU frequency in hertz.
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) and 16 bytes (128 bits) are common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig)
+```
+
+Configure configures a ADC pin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type DAC
+
+```go
+type DAC struct {
+}
+```
+
+DAC on the SAMD21.
+
+
+
+### func (DAC) Configure
+
+```go
+func (dac DAC) Configure(config DACConfig)
+```
+
+Configure the DAC.
+output pin must already be configured.
+
+
+### func (DAC) Set
+
+```go
+func (dac DAC) Set(value uint16) error
+```
+
+Set writes a single 16-bit value to the DAC.
+Since the ATSAMD21 only has a 10-bit DAC, the passed-in value will be scaled down.
+
+
+
+
+## type DACConfig
+
+```go
+type DACConfig struct {
+}
+```
+
+DACConfig placeholder for future expansion.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*sam.SERCOM_I2CM_Type
+	SERCOM	uint8
+}
+```
+
+I2C on the SAMD21.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteByte
+
+```go
+func (i2c *I2C) WriteByte(data byte) error
+```
+
+WriteByte writes a single byte to the I2C bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type I2S
+
+```go
+type I2S struct {
+	Bus		*sam.I2S_Type
+	Frequency	uint32
+	DataFormat	I2SDataFormat
+}
+```
+
+I2S
+
+
+
+### func (*I2S) Configure
+
+```go
+func (i2s *I2S) Configure(config I2SConfig) error
+```
+
+Configure is used to configure the I2S interface. You must call this
+before you can use the I2S bus.
+
+
+### func (*I2S) Enable
+
+```go
+func (i2s *I2S) Enable(enabled bool)
+```
+
+Enabled is used to enable or disable the I2S bus.
+
+
+### func (*I2S) ReadMono
+
+```go
+func (i2s *I2S) ReadMono(p []uint16) (n int, err error)
+```
+
+Read mono data from the I2S bus into the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) ReadStereo
+
+```go
+func (i2s *I2S) ReadStereo(p []uint32) (n int, err error)
+```
+
+Read stereo data from the I2S bus into the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) SetSampleFrequency
+
+```go
+func (i2s *I2S) SetSampleFrequency(freq uint32) error
+```
+
+SetSampleFrequency is used to set the sample frequency for the I2S bus.
+
+
+### func (*I2S) WriteMono
+
+```go
+func (i2s *I2S) WriteMono(p []uint16) (n int, err error)
+```
+
+Write mono data to the I2S bus from the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) WriteStereo
+
+```go
+func (i2s *I2S) WriteStereo(p []uint32) (n int, err error)
+```
+
+Write stereo data to the I2S bus from the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+
+
+## type I2SClockSource
+
+```go
+type I2SClockSource uint8
+```
+
+
+
+
+
+
+## type I2SConfig
+
+```go
+type I2SConfig struct {
+	// clock
+	SCK	Pin
+	// word select
+	WS	Pin
+	// data out
+	SDO	Pin
+	// data in
+	SDI		Pin
+	Mode		I2SMode
+	Standard	I2SStandard
+	ClockSource	I2SClockSource
+	DataFormat	I2SDataFormat
+	AudioFrequency	uint32
+	MainClockOutput	bool
+	Stereo		bool
+}
+```
+
+All fields are optional and may not be required or used on a particular platform.
+
+
+
+
+
+## type I2SDataFormat
+
+```go
+type I2SDataFormat uint8
+```
+
+
+
+
+
+
+## type I2SMode
+
+```go
+type I2SMode uint8
+```
+
+
+
+
+
+
+## type I2SStandard
+
+```go
+type I2SStandard uint8
+```
+
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when configured as an input or as
+an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*sam.SERCOM_SPI_Type
+	SERCOM	uint8
+}
+```
+
+SPI
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type TCC
+
+```go
+type TCC sam.TCC_Type
+```
+
+TCC is one timer/counter peripheral, which consists of a counter and multiple
+output channels (that can be connected to actual pins). You can set the
+frequency using SetPeriod, but only for all the channels in this TCC
+peripheral at once.
+
+
+
+### func (*TCC) Channel
+
+```go
+func (tcc *TCC) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin. Note that one channel may be
+shared between multiple pins, and so will have the same duty cycle. If this
+is not desirable, look for a different TCC peripheral or consider using a
+different pin.
+
+
+### func (*TCC) Configure
+
+```go
+func (tcc *TCC) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this TCC.
+
+
+### func (*TCC) Counter
+
+```go
+func (tcc *TCC) Counter() uint32
+```
+
+Counter returns the current counter value of the timer in this TCC
+peripheral. It may be useful for debugging.
+
+
+### func (*TCC) Set
+
+```go
+func (tcc *TCC) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle, in other words the fraction of time the channel output is high (or low
+when inverted). For example, to set it to a 25% duty cycle, use:
+
+	tcc.Set(channel, tcc.Top() / 4)
+
+tcc.Set(channel, 0) will set the output to low and tcc.Set(channel,
+tcc.Top()) will set the output to high, assuming the output isn't inverted.
+
+
+### func (*TCC) SetInverting
+
+```go
+func (tcc *TCC) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TCC) SetPeriod
+
+```go
+func (tcc *TCC) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this TCC peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the TCC peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TCC) Top
+
+```go
+func (tcc *TCC) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to Set
+(see Set documentation for more information).
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*sam.SERCOM_USART_Type
+	SERCOM		uint8
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the SAMD21.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/trinkey-qt2040.md b/content/docs/reference/microcontrollers/machine/trinkey-qt2040.md
new file mode 100644
index 00000000..e7bc5fcd
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/trinkey-qt2040.md
@@ -0,0 +1,1645 @@
+
+---
+title: trinkey-qt2040
+---
+
+
+## Constants
+
+```go
+const (
+	NEOPIXEL	= GPIO27
+	WS2812		= NEOPIXEL
+)
+```
+
+Onboard LEDs
+
+
+```go
+const (
+	I2C0_SDA_PIN	= GPIO16
+	I2C0_SCL_PIN	= GPIO17
+
+	I2C1_SDA_PIN	= NoPin
+	I2C1_SCL_PIN	= NoPin
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= NoPin
+	SPI0_SDO_PIN	= NoPin
+	SPI0_SDI_PIN	= NoPin
+
+	SPI1_SCK_PIN	= NoPin
+	SPI1_SDO_PIN	= NoPin
+	SPI1_SDI_PIN	= NoPin
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	UART0_TX_PIN	= NoPin
+	UART0_RX_PIN	= NoPin
+	UART_TX_PIN	= UART0_TX_PIN
+	UART_RX_PIN	= UART0_RX_PIN
+)
+```
+
+UART pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	LS_SE0	= 0b00
+	LS_J	= 0b01
+	LS_K	= 0b10
+	LS_SE1	= 0b11
+)
+```
+
+
+
+```go
+const (
+	cpuFreq			= 200 * MHz
+	_NUMBANK0_GPIOS		= 30
+	_NUMBANK0_IRQS		= 4
+	_NUMIRQ			= 32
+	rp2350ExtraReg		= 0
+	RESETS_RESET_Msk	= 0x01ffffff
+	initUnreset		= rp.RESETS_RESET_ADC |
+		rp.RESETS_RESET_RTC |
+		rp.RESETS_RESET_SPI0 |
+		rp.RESETS_RESET_SPI1 |
+		rp.RESETS_RESET_UART0 |
+		rp.RESETS_RESET_UART1 |
+		rp.RESETS_RESET_USBCTRL
+	initDontReset	= rp.RESETS_RESET_IO_QSPI |
+		rp.RESETS_RESET_PADS_QSPI |
+		rp.RESETS_RESET_PLL_USB |
+		rp.RESETS_RESET_USBCTRL |
+		rp.RESETS_RESET_SYSCFG |
+		rp.RESETS_RESET_PLL_SYS
+	padEnableMask	= rp.PADS_BANK0_GPIO0_IE_Msk |
+		rp.PADS_BANK0_GPIO0_OD_Msk
+)
+```
+
+
+
+```go
+const (
+	PinOutput	PinMode	= iota
+	PinInput
+	PinInputPulldown
+	PinInputPullup
+	PinAnalog
+	PinUART
+	PinPWM
+	PinI2C
+	PinSPI
+	PinPIO0
+	PinPIO1
+)
+```
+
+
+
+```go
+const (
+	ADC0	Pin	= GPIO26
+	ADC1	Pin	= GPIO27
+	ADC2	Pin	= GPIO28
+	ADC3	Pin	= GPIO29
+
+	thermADC	= 30
+)
+```
+
+Analog pins on RP2040.
+
+
+```go
+const (
+	// Edge falling
+	PinFalling	PinChange	= 4 << iota
+	// Edge rising
+	PinRising
+
+	PinToggle	= PinFalling | PinRising
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// GPIO pins
+	GPIO0	Pin	= 0	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO1	Pin	= 1	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO2	Pin	= 2	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO3	Pin	= 3	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO4	Pin	= 4	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO5	Pin	= 5	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO6	Pin	= 6	// peripherals: PWM3 channel A, I2C1 SDA
+	GPIO7	Pin	= 7	// peripherals: PWM3 channel B, I2C1 SCL
+	GPIO8	Pin	= 8	// peripherals: PWM4 channel A, I2C0 SDA
+	GPIO9	Pin	= 9	// peripherals: PWM4 channel B, I2C0 SCL
+	GPIO10	Pin	= 10	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO11	Pin	= 11	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO12	Pin	= 12	// peripherals: PWM6 channel A, I2C0 SDA
+	GPIO13	Pin	= 13	// peripherals: PWM6 channel B, I2C0 SCL
+	GPIO14	Pin	= 14	// peripherals: PWM7 channel A, I2C1 SDA
+	GPIO15	Pin	= 15	// peripherals: PWM7 channel B, I2C1 SCL
+	GPIO16	Pin	= 16	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO17	Pin	= 17	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO18	Pin	= 18	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO19	Pin	= 19	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO20	Pin	= 20	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO21	Pin	= 21	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO22	Pin	= 22	// peripherals: PWM3 channel A
+	GPIO23	Pin	= 23	// peripherals: PWM3 channel B
+	GPIO24	Pin	= 24	// peripherals: PWM4 channel A
+	GPIO25	Pin	= 25	// peripherals: PWM4 channel B
+	GPIO26	Pin	= 26	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO27	Pin	= 27	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO28	Pin	= 28	// peripherals: PWM6 channel A
+	GPIO29	Pin	= 29	// peripherals: PWM6 channel B
+)
+```
+
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 8.3s).
+	//
+	// Nominal 1us per watchdog tick, 24-bit counter,
+	// but due to errata two ticks consumed per 1us.
+	// See: Errata RP2040-E1
+	WatchdogMaxTimeout = (rp.WATCHDOG_LOAD_LOAD_Msk / 1000) / 2
+)
+```
+
+
+
+```go
+const XOSC_STARTUP_DELAY_MULTIPLIER = 64
+```
+
+On some boards, the XOSC can take longer than usual to stabilize. On such
+boards, this is needed to avoid a hard fault on boot/reset. Refer to
+PICO_XOSC_STARTUP_DELAY_MULTIPLIER in the Pico SDK for additional details.
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	UART0	= &_UART0
+	_UART0	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART0,
+	}
+
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART1,
+	}
+)
+```
+
+UART on the RP2040
+
+
+```go
+var RTC = (*rtcType)(unsafe.Pointer(rp.RTC))
+```
+
+
+
+```go
+var (
+	ErrRtcDelayTooSmall	= errors.New("RTC interrupt deplay is too small, shall be at least 1 second")
+	ErrRtcDelayTooLarge	= errors.New("RTC interrupt deplay is too large, shall be no more than 1 day")
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	I2C0	= &_I2C0
+	_I2C0	= I2C{
+		Bus: rp.I2C0,
+	}
+	I2C1	= &_I2C1
+	_I2C1	= I2C{
+		Bus: rp.I2C1,
+	}
+)
+```
+
+I2C on the RP2040/RP2350
+
+
+```go
+var (
+	ErrBadPeriod = errors.New("period outside valid range 8ns..268ms")
+)
+```
+
+
+
+```go
+var (
+	PWM0	= getPWMGroup(0)
+	PWM1	= getPWMGroup(1)
+	PWM2	= getPWMGroup(2)
+	PWM3	= getPWMGroup(3)
+	PWM4	= getPWMGroup(4)
+	PWM5	= getPWMGroup(5)
+	PWM6	= getPWMGroup(6)
+	PWM7	= getPWMGroup(7)
+)
+```
+
+Hardware Pulse Width Modulation (PWM) API
+PWM peripherals available on RP2040. Each peripheral has 2 pins available for
+a total of 16 available PWM outputs. Some pins may not be available on some boards.
+
+The RP2040 PWM block has 8 identical slices. Each slice can drive two PWM output signals, or
+measure the frequency or duty cycle of an input signal. This gives a total of up to 16 controllable
+PWM outputs. All 30 GPIOs can be driven by the PWM block
+
+The PWM hardware functions by continuously comparing the input value to a free-running counter. This produces a
+toggling output where the amount of time spent at the high output level is proportional to the input value. The fraction of
+time spent at the high signal level is known as the duty cycle of the signal.
+
+The default behaviour of a PWM slice is to count upward until the wrap value (\ref pwm_config_set_wrap) is reached, and then
+immediately wrap to 0. PWM slices also offer a phase-correct mode, where the counter starts to count downward after
+reaching TOP, until it reaches 0 again.
+
+
+```go
+var (
+	SPI0	= &SPI{
+		Bus: rp.SPI0,
+	}
+	SPI1	= &SPI{
+		Bus: rp.SPI1,
+	}
+)
+```
+
+SPI on the RP2040
+
+
+```go
+var (
+	ErrLSBNotSupported	= errors.New("SPI LSB unsupported on PL022")
+	ErrSPITimeout		= errors.New("SPI timeout")
+	ErrSPIBaud		= errors.New("SPI baud too low or above 66.5Mhz")
+	errSPIInvalidSDI	= errors.New("invalid SPI SDI pin")
+	errSPIInvalidSDO	= errors.New("invalid SPI SDO pin")
+	errSPIInvalidSCK	= errors.New("invalid SPI SCK pin")
+)
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the RP2040.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ChipVersion
+
+```go
+func ChipVersion() uint8
+```
+
+ChipVersion returns the version of the chip. 1 is returned for B0 and B1
+chip.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func CurrentCore
+
+```go
+func CurrentCore() int
+```
+
+CurrentCore returns the core number the call was made from.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of semi-random data based on ring oscillator.
+
+Unlike some other implementations of GetRNG, these random numbers are not
+cryptographically secure and must not be used for cryptographic operations
+(nonces, etc).
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC resets the ADC peripheral.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func NumCores
+
+```go
+func NumCores() int
+```
+
+NumCores returns number of cores available on the device.
+
+
+### func PWMPeripheral
+
+```go
+func PWMPeripheral(pin Pin) (sliceNum uint8, err error)
+```
+
+Peripheral returns the RP2040 PWM peripheral which ranges from 0 to 7. Each
+PWM peripheral has 2 channels, A and B which correspond to 0 and 1 in the program.
+This number corresponds to the package's PWM0 throughout PWM7 handles
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() (millicelsius int32)
+```
+
+ReadTemperature does a one-shot sample of the internal temperature sensor and returns a milli-celsius reading.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig) error
+```
+
+Configure sets the ADC pin to analog input mode.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns a one-shot ADC sample reading.
+
+
+### func (ADC) GetADCChannel
+
+```go
+func (a ADC) GetADCChannel() (c ADCChannel, err error)
+```
+
+GetADCChannel returns the channel associated with the ADC pin.
+
+
+
+
+## type ADCChannel
+
+```go
+type ADCChannel uint8
+```
+
+ADCChannel is the ADC peripheral mux channel. 0-4.
+
+
+
+### func (ADCChannel) Configure
+
+```go
+func (c ADCChannel) Configure(config ADCConfig) error
+```
+
+Configure sets the channel's associated pin to analog input mode.
+The powered on temperature sensor increases ADC_AVDD current by approximately 40 μA.
+
+
+### func (ADCChannel) Pin
+
+```go
+func (c ADCChannel) Pin() (p Pin, err error)
+```
+
+The Pin method returns the GPIO Pin associated with the ADC mux channel, if it has one.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*rp.I2C0_Type
+	mode		I2CMode
+	txInProgress	bool
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure initializes i2c peripheral and configures I2C config's pins passed.
+Here's a list of valid SDA and SCL GPIO pins on bus I2C0 of the rp2040:
+
+	SDA: 0, 4, 8, 12, 16, 20
+	SCL: 1, 5, 9, 13, 17, 21
+
+Same as above for I2C1 bus:
+
+	SDA: 2, 6, 10, 14, 18, 26
+	SCL: 3, 7, 11, 15, 19, 27
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint16) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx performs a write and then a read transfer placing the result in
+in r.
+
+Passing a nil value for w or r skips the transfer corresponding to write
+or read, respectively.
+
+	i2c.Tx(addr, nil, r)
+
+Performs only a read transfer.
+
+	i2c.Tx(addr, w, nil)
+
+Performs only a write transfer.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	// SDA/SCL Serial Data and clock pins. Refer to datasheet to see
+	// which pins match the desired bus.
+	SDA, SCL	Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure configures the gpio pin as per mode.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get reads the pin value.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set drives the pin high if value is true else drives it low.
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+PinChange represents one or more trigger events that can happen on a given GPIO pin
+on the RP2040. ORed PinChanges are valid input to most IRQ functions.
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus *rp.SPI0_Type
+}
+```
+
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup/initialize the SPI interface.
+Default baudrate of 4MHz is used if Frequency == 0. Default
+word length (data bits) is 8.
+Below is a list of GPIO pins corresponding to SPI0 bus on the rp2040:
+
+	SI : 0, 4, 17  a.k.a RX and MISO (if rp2040 is master)
+	SO : 3, 7, 19  a.k.a TX and MOSI (if rp2040 is master)
+	SCK: 2, 6, 18
+
+SPI1 bus GPIO pins:
+
+	SI : 8, 12
+	SO : 11, 15
+	SCK: 10, 14
+
+No pin configuration is needed of SCK, SDO and SDI needed after calling Configure.
+
+
+### func (*SPI) GetBaudRate
+
+```go
+func (spi *SPI) GetBaudRate() uint32
+```
+
+
+
+### func (*SPI) PrintRegs
+
+```go
+func (spi *SPI) PrintRegs()
+```
+
+PrintRegs prints SPI's peripheral common registries current values
+
+
+### func (*SPI) SetBaudRate
+
+```go
+func (spi *SPI) SetBaudRate(br uint32) error
+```
+
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Write a single byte and read a single byte from TX/RX FIFO.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) (err error)
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+Remark: This implementation (RP2040) allows reading into buffer with a custom repeated
+value on tx.
+
+	spi.Tx([]byte{0xff}, rx) // may cause unwanted heap allocations.
+
+This form sends 0xff and puts the result into rx buffer. Useful for reading from SD cards
+which require 0xff input on SI.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	// LSB not supported on rp2040.
+	LSBFirst	bool
+	// Mode's two most LSB are CPOL and CPHA. i.e. Mode==2 (0b10) is CPOL=1, CPHA=0
+	Mode	uint8
+	// Serial clock pin
+	SCK	Pin
+	// TX or Serial Data Out (MOSI if rp2040 is master)
+	SDO	Pin
+	// RX or Serial Data In (MISO if rp2040 is master)
+	SDI	Pin
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*rp.UART0_Type
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the RP2040.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the baudrate to be used for the UART.
+
+
+### func (*UART) SetFormat
+
+```go
+func (uart *UART) SetFormat(databits, stopbits uint8, parity UARTParity) error
+```
+
+SetFormat for number of data bits, stop bits, and parity for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) ClearStallEPIn
+
+```go
+func (dev *USBDevice) ClearStallEPIn(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB IN endpoint.
+
+
+### func (*USBDevice) ClearStallEPOut
+
+```go
+func (dev *USBDevice) ClearStallEPOut(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB OUT endpoint.
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+### func (*USBDevice) SetStallEPIn
+
+```go
+func (dev *USBDevice) SetStallEPIn(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB IN endpoint.
+
+
+### func (*USBDevice) SetStallEPOut
+
+```go
+func (dev *USBDevice) SetStallEPOut(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB OUT endpoint.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/tufty2040.md b/content/docs/reference/microcontrollers/machine/tufty2040.md
new file mode 100644
index 00000000..07fc5a17
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/tufty2040.md
@@ -0,0 +1,1676 @@
+
+---
+title: tufty2040
+---
+
+
+## Constants
+
+```go
+const (
+	LED	Pin	= GPIO25
+
+	BUTTON_A	Pin	= GPIO7
+	BUTTON_B	Pin	= GPIO8
+	BUTTON_C	Pin	= GPIO9
+	BUTTON_UP	Pin	= GPIO22
+	BUTTON_DOWN	Pin	= GPIO6
+	BUTTON_USER	Pin	= GPIO23
+
+	LCD_BACKLIGHT	Pin	= GPIO2
+	LCD_CS		Pin	= GPIO10
+	LCD_DC		Pin	= GPIO11
+	LCD_WR		Pin	= GPIO12
+	LCD_RD		Pin	= GPIO13
+	LCD_DB0		Pin	= GPIO14
+	LCD_DB1		Pin	= GPIO15
+	LCD_DB2		Pin	= GPIO16
+	LCD_DB3		Pin	= GPIO17
+	LCD_DB4		Pin	= GPIO18
+	LCD_DB5		Pin	= GPIO19
+	LCD_DB6		Pin	= GPIO20
+	LCD_DB7		Pin	= GPIO21
+
+	VBUS_DETECT	Pin	= GPIO24
+	BATTERY		Pin	= GPIO29
+	USER_LED	Pin	= GPIO25
+	LIGHT_SENSE	Pin	= GPIO26
+	SENSOR_POWER	Pin	= GPIO27
+)
+```
+
+
+
+```go
+const (
+	I2C0_SDA_PIN	Pin	= GPIO4
+	I2C0_SCL_PIN	Pin	= GPIO5
+
+	I2C1_SDA_PIN	Pin	= NoPin
+	I2C1_SCL_PIN	Pin	= NoPin
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	Pin	= NoPin
+	SPI0_SDO_PIN	Pin	= NoPin
+	SPI0_SDI_PIN	Pin	= NoPin
+
+	SPI1_SCK_PIN	Pin	= NoPin
+	SPI1_SDO_PIN	Pin	= NoPin
+	SPI1_SDI_PIN	Pin	= NoPin
+)
+```
+
+SPI pins.
+
+
+```go
+const (
+	UART0_TX_PIN	= GPIO0
+	UART0_RX_PIN	= GPIO1
+	UART_TX_PIN	= UART0_TX_PIN
+	UART_RX_PIN	= UART0_RX_PIN
+)
+```
+
+UART pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	LS_SE0	= 0b00
+	LS_J	= 0b01
+	LS_K	= 0b10
+	LS_SE1	= 0b11
+)
+```
+
+
+
+```go
+const (
+	cpuFreq			= 200 * MHz
+	_NUMBANK0_GPIOS		= 30
+	_NUMBANK0_IRQS		= 4
+	_NUMIRQ			= 32
+	rp2350ExtraReg		= 0
+	RESETS_RESET_Msk	= 0x01ffffff
+	initUnreset		= rp.RESETS_RESET_ADC |
+		rp.RESETS_RESET_RTC |
+		rp.RESETS_RESET_SPI0 |
+		rp.RESETS_RESET_SPI1 |
+		rp.RESETS_RESET_UART0 |
+		rp.RESETS_RESET_UART1 |
+		rp.RESETS_RESET_USBCTRL
+	initDontReset	= rp.RESETS_RESET_IO_QSPI |
+		rp.RESETS_RESET_PADS_QSPI |
+		rp.RESETS_RESET_PLL_USB |
+		rp.RESETS_RESET_USBCTRL |
+		rp.RESETS_RESET_SYSCFG |
+		rp.RESETS_RESET_PLL_SYS
+	padEnableMask	= rp.PADS_BANK0_GPIO0_IE_Msk |
+		rp.PADS_BANK0_GPIO0_OD_Msk
+)
+```
+
+
+
+```go
+const (
+	PinOutput	PinMode	= iota
+	PinInput
+	PinInputPulldown
+	PinInputPullup
+	PinAnalog
+	PinUART
+	PinPWM
+	PinI2C
+	PinSPI
+	PinPIO0
+	PinPIO1
+)
+```
+
+
+
+```go
+const (
+	ADC0	Pin	= GPIO26
+	ADC1	Pin	= GPIO27
+	ADC2	Pin	= GPIO28
+	ADC3	Pin	= GPIO29
+
+	thermADC	= 30
+)
+```
+
+Analog pins on RP2040.
+
+
+```go
+const (
+	// Edge falling
+	PinFalling	PinChange	= 4 << iota
+	// Edge rising
+	PinRising
+
+	PinToggle	= PinFalling | PinRising
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// GPIO pins
+	GPIO0	Pin	= 0	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO1	Pin	= 1	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO2	Pin	= 2	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO3	Pin	= 3	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO4	Pin	= 4	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO5	Pin	= 5	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO6	Pin	= 6	// peripherals: PWM3 channel A, I2C1 SDA
+	GPIO7	Pin	= 7	// peripherals: PWM3 channel B, I2C1 SCL
+	GPIO8	Pin	= 8	// peripherals: PWM4 channel A, I2C0 SDA
+	GPIO9	Pin	= 9	// peripherals: PWM4 channel B, I2C0 SCL
+	GPIO10	Pin	= 10	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO11	Pin	= 11	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO12	Pin	= 12	// peripherals: PWM6 channel A, I2C0 SDA
+	GPIO13	Pin	= 13	// peripherals: PWM6 channel B, I2C0 SCL
+	GPIO14	Pin	= 14	// peripherals: PWM7 channel A, I2C1 SDA
+	GPIO15	Pin	= 15	// peripherals: PWM7 channel B, I2C1 SCL
+	GPIO16	Pin	= 16	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO17	Pin	= 17	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO18	Pin	= 18	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO19	Pin	= 19	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO20	Pin	= 20	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO21	Pin	= 21	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO22	Pin	= 22	// peripherals: PWM3 channel A
+	GPIO23	Pin	= 23	// peripherals: PWM3 channel B
+	GPIO24	Pin	= 24	// peripherals: PWM4 channel A
+	GPIO25	Pin	= 25	// peripherals: PWM4 channel B
+	GPIO26	Pin	= 26	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO27	Pin	= 27	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO28	Pin	= 28	// peripherals: PWM6 channel A
+	GPIO29	Pin	= 29	// peripherals: PWM6 channel B
+)
+```
+
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 8.3s).
+	//
+	// Nominal 1us per watchdog tick, 24-bit counter,
+	// but due to errata two ticks consumed per 1us.
+	// See: Errata RP2040-E1
+	WatchdogMaxTimeout = (rp.WATCHDOG_LOAD_LOAD_Msk / 1000) / 2
+)
+```
+
+
+
+```go
+const XOSC_STARTUP_DELAY_MULTIPLIER = 64
+```
+
+On some boards, the XOSC can take longer than usual to stabilize. On such
+boards, this is needed to avoid a hard fault on boot/reset. Refer to
+PICO_XOSC_STARTUP_DELAY_MULTIPLIER in the Pico SDK for additional details.
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	UART0	= &_UART0
+	_UART0	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART0,
+	}
+
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART1,
+	}
+)
+```
+
+UART on the RP2040
+
+
+```go
+var RTC = (*rtcType)(unsafe.Pointer(rp.RTC))
+```
+
+
+
+```go
+var (
+	ErrRtcDelayTooSmall	= errors.New("RTC interrupt deplay is too small, shall be at least 1 second")
+	ErrRtcDelayTooLarge	= errors.New("RTC interrupt deplay is too large, shall be no more than 1 day")
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	I2C0	= &_I2C0
+	_I2C0	= I2C{
+		Bus: rp.I2C0,
+	}
+	I2C1	= &_I2C1
+	_I2C1	= I2C{
+		Bus: rp.I2C1,
+	}
+)
+```
+
+I2C on the RP2040/RP2350
+
+
+```go
+var (
+	ErrBadPeriod = errors.New("period outside valid range 8ns..268ms")
+)
+```
+
+
+
+```go
+var (
+	PWM0	= getPWMGroup(0)
+	PWM1	= getPWMGroup(1)
+	PWM2	= getPWMGroup(2)
+	PWM3	= getPWMGroup(3)
+	PWM4	= getPWMGroup(4)
+	PWM5	= getPWMGroup(5)
+	PWM6	= getPWMGroup(6)
+	PWM7	= getPWMGroup(7)
+)
+```
+
+Hardware Pulse Width Modulation (PWM) API
+PWM peripherals available on RP2040. Each peripheral has 2 pins available for
+a total of 16 available PWM outputs. Some pins may not be available on some boards.
+
+The RP2040 PWM block has 8 identical slices. Each slice can drive two PWM output signals, or
+measure the frequency or duty cycle of an input signal. This gives a total of up to 16 controllable
+PWM outputs. All 30 GPIOs can be driven by the PWM block
+
+The PWM hardware functions by continuously comparing the input value to a free-running counter. This produces a
+toggling output where the amount of time spent at the high output level is proportional to the input value. The fraction of
+time spent at the high signal level is known as the duty cycle of the signal.
+
+The default behaviour of a PWM slice is to count upward until the wrap value (\ref pwm_config_set_wrap) is reached, and then
+immediately wrap to 0. PWM slices also offer a phase-correct mode, where the counter starts to count downward after
+reaching TOP, until it reaches 0 again.
+
+
+```go
+var (
+	SPI0	= &SPI{
+		Bus: rp.SPI0,
+	}
+	SPI1	= &SPI{
+		Bus: rp.SPI1,
+	}
+)
+```
+
+SPI on the RP2040
+
+
+```go
+var (
+	ErrLSBNotSupported	= errors.New("SPI LSB unsupported on PL022")
+	ErrSPITimeout		= errors.New("SPI timeout")
+	ErrSPIBaud		= errors.New("SPI baud too low or above 66.5Mhz")
+	errSPIInvalidSDI	= errors.New("invalid SPI SDI pin")
+	errSPIInvalidSDO	= errors.New("invalid SPI SDO pin")
+	errSPIInvalidSCK	= errors.New("invalid SPI SCK pin")
+)
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the RP2040.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ChipVersion
+
+```go
+func ChipVersion() uint8
+```
+
+ChipVersion returns the version of the chip. 1 is returned for B0 and B1
+chip.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func CurrentCore
+
+```go
+func CurrentCore() int
+```
+
+CurrentCore returns the core number the call was made from.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of semi-random data based on ring oscillator.
+
+Unlike some other implementations of GetRNG, these random numbers are not
+cryptographically secure and must not be used for cryptographic operations
+(nonces, etc).
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC resets the ADC peripheral.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func NumCores
+
+```go
+func NumCores() int
+```
+
+NumCores returns number of cores available on the device.
+
+
+### func PWMPeripheral
+
+```go
+func PWMPeripheral(pin Pin) (sliceNum uint8, err error)
+```
+
+Peripheral returns the RP2040 PWM peripheral which ranges from 0 to 7. Each
+PWM peripheral has 2 channels, A and B which correspond to 0 and 1 in the program.
+This number corresponds to the package's PWM0 throughout PWM7 handles
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() (millicelsius int32)
+```
+
+ReadTemperature does a one-shot sample of the internal temperature sensor and returns a milli-celsius reading.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig) error
+```
+
+Configure sets the ADC pin to analog input mode.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns a one-shot ADC sample reading.
+
+
+### func (ADC) GetADCChannel
+
+```go
+func (a ADC) GetADCChannel() (c ADCChannel, err error)
+```
+
+GetADCChannel returns the channel associated with the ADC pin.
+
+
+
+
+## type ADCChannel
+
+```go
+type ADCChannel uint8
+```
+
+ADCChannel is the ADC peripheral mux channel. 0-4.
+
+
+
+### func (ADCChannel) Configure
+
+```go
+func (c ADCChannel) Configure(config ADCConfig) error
+```
+
+Configure sets the channel's associated pin to analog input mode.
+The powered on temperature sensor increases ADC_AVDD current by approximately 40 μA.
+
+
+### func (ADCChannel) Pin
+
+```go
+func (c ADCChannel) Pin() (p Pin, err error)
+```
+
+The Pin method returns the GPIO Pin associated with the ADC mux channel, if it has one.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*rp.I2C0_Type
+	mode		I2CMode
+	txInProgress	bool
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure initializes i2c peripheral and configures I2C config's pins passed.
+Here's a list of valid SDA and SCL GPIO pins on bus I2C0 of the rp2040:
+
+	SDA: 0, 4, 8, 12, 16, 20
+	SCL: 1, 5, 9, 13, 17, 21
+
+Same as above for I2C1 bus:
+
+	SDA: 2, 6, 10, 14, 18, 26
+	SCL: 3, 7, 11, 15, 19, 27
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint16) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx performs a write and then a read transfer placing the result in
+in r.
+
+Passing a nil value for w or r skips the transfer corresponding to write
+or read, respectively.
+
+	i2c.Tx(addr, nil, r)
+
+Performs only a read transfer.
+
+	i2c.Tx(addr, w, nil)
+
+Performs only a write transfer.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	// SDA/SCL Serial Data and clock pins. Refer to datasheet to see
+	// which pins match the desired bus.
+	SDA, SCL	Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure configures the gpio pin as per mode.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get reads the pin value.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set drives the pin high if value is true else drives it low.
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+PinChange represents one or more trigger events that can happen on a given GPIO pin
+on the RP2040. ORed PinChanges are valid input to most IRQ functions.
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus *rp.SPI0_Type
+}
+```
+
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup/initialize the SPI interface.
+Default baudrate of 4MHz is used if Frequency == 0. Default
+word length (data bits) is 8.
+Below is a list of GPIO pins corresponding to SPI0 bus on the rp2040:
+
+	SI : 0, 4, 17  a.k.a RX and MISO (if rp2040 is master)
+	SO : 3, 7, 19  a.k.a TX and MOSI (if rp2040 is master)
+	SCK: 2, 6, 18
+
+SPI1 bus GPIO pins:
+
+	SI : 8, 12
+	SO : 11, 15
+	SCK: 10, 14
+
+No pin configuration is needed of SCK, SDO and SDI needed after calling Configure.
+
+
+### func (*SPI) GetBaudRate
+
+```go
+func (spi *SPI) GetBaudRate() uint32
+```
+
+
+
+### func (*SPI) PrintRegs
+
+```go
+func (spi *SPI) PrintRegs()
+```
+
+PrintRegs prints SPI's peripheral common registries current values
+
+
+### func (*SPI) SetBaudRate
+
+```go
+func (spi *SPI) SetBaudRate(br uint32) error
+```
+
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Write a single byte and read a single byte from TX/RX FIFO.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) (err error)
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+Remark: This implementation (RP2040) allows reading into buffer with a custom repeated
+value on tx.
+
+	spi.Tx([]byte{0xff}, rx) // may cause unwanted heap allocations.
+
+This form sends 0xff and puts the result into rx buffer. Useful for reading from SD cards
+which require 0xff input on SI.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	// LSB not supported on rp2040.
+	LSBFirst	bool
+	// Mode's two most LSB are CPOL and CPHA. i.e. Mode==2 (0b10) is CPOL=1, CPHA=0
+	Mode	uint8
+	// Serial clock pin
+	SCK	Pin
+	// TX or Serial Data Out (MOSI if rp2040 is master)
+	SDO	Pin
+	// RX or Serial Data In (MISO if rp2040 is master)
+	SDI	Pin
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*rp.UART0_Type
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the RP2040.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the baudrate to be used for the UART.
+
+
+### func (*UART) SetFormat
+
+```go
+func (uart *UART) SetFormat(databits, stopbits uint8, parity UARTParity) error
+```
+
+SetFormat for number of data bits, stop bits, and parity for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) ClearStallEPIn
+
+```go
+func (dev *USBDevice) ClearStallEPIn(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB IN endpoint.
+
+
+### func (*USBDevice) ClearStallEPOut
+
+```go
+func (dev *USBDevice) ClearStallEPOut(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB OUT endpoint.
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+### func (*USBDevice) SetStallEPIn
+
+```go
+func (dev *USBDevice) SetStallEPIn(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB IN endpoint.
+
+
+### func (*USBDevice) SetStallEPOut
+
+```go
+func (dev *USBDevice) SetStallEPOut(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB OUT endpoint.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/waveshare-rp2040-zero.md b/content/docs/reference/microcontrollers/machine/waveshare-rp2040-zero.md
new file mode 100644
index 00000000..2995a0b5
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/waveshare-rp2040-zero.md
@@ -0,0 +1,1703 @@
+
+---
+title: waveshare-rp2040-zero
+---
+
+
+## Constants
+
+```go
+const (
+	D0	Pin	= GPIO0
+	D1	Pin	= GPIO1
+	D2	Pin	= GPIO2
+	D3	Pin	= GPIO3
+	D4	Pin	= GPIO4
+	D5	Pin	= GPIO5
+	D6	Pin	= GPIO6
+	D7	Pin	= GPIO7
+	D8	Pin	= GPIO8
+	D9	Pin	= GPIO9
+	D10	Pin	= GPIO10
+	D11	Pin	= GPIO11
+	D12	Pin	= GPIO12
+	D13	Pin	= GPIO13
+	D14	Pin	= GPIO14
+	D15	Pin	= GPIO15
+	D16	Pin	= GPIO16
+	D17	Pin	= GPIO17
+	D18	Pin	= GPIO18
+	D19	Pin	= GPIO19
+	D20	Pin	= GPIO20
+	D21	Pin	= GPIO21
+	D22	Pin	= GPIO22
+	D23	Pin	= GPIO23
+	D24	Pin	= GPIO24
+	D25	Pin	= GPIO25
+	D26	Pin	= GPIO26
+	D27	Pin	= GPIO27
+	D28	Pin	= GPIO28
+	D29	Pin	= GPIO29
+)
+```
+
+Digital Pins
+
+
+```go
+const (
+	A0	Pin	= D26
+	A1	Pin	= D27
+	A2	Pin	= D28
+	A3	Pin	= D29
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	NEOPIXEL	= GPIO16
+	WS2812		= GPIO16
+)
+```
+
+Onboard LEDs
+
+
+```go
+const (
+	I2C0_SDA_PIN	Pin	= D0
+	I2C0_SCL_PIN	Pin	= D1
+
+	I2C1_SDA_PIN	Pin	= D2
+	I2C1_SCL_PIN	Pin	= D3
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	Pin	= D6
+	SPI0_SDO_PIN	Pin	= D3
+	SPI0_SDI_PIN	Pin	= D4
+
+	SPI1_SCK_PIN	Pin	= D10
+	SPI1_SDO_PIN	Pin	= D11
+	SPI1_SDI_PIN	Pin	= D12
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	UART0_TX_PIN	= GPIO0
+	UART0_RX_PIN	= GPIO1
+	UART_TX_PIN	= UART0_TX_PIN
+	UART_RX_PIN	= UART0_RX_PIN
+	UART1_TX_PIN	= GPIO8
+	UART1_RX_PIN	= GPIO9
+)
+```
+
+UART pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	LS_SE0	= 0b00
+	LS_J	= 0b01
+	LS_K	= 0b10
+	LS_SE1	= 0b11
+)
+```
+
+
+
+```go
+const (
+	cpuFreq			= 200 * MHz
+	_NUMBANK0_GPIOS		= 30
+	_NUMBANK0_IRQS		= 4
+	_NUMIRQ			= 32
+	rp2350ExtraReg		= 0
+	RESETS_RESET_Msk	= 0x01ffffff
+	initUnreset		= rp.RESETS_RESET_ADC |
+		rp.RESETS_RESET_RTC |
+		rp.RESETS_RESET_SPI0 |
+		rp.RESETS_RESET_SPI1 |
+		rp.RESETS_RESET_UART0 |
+		rp.RESETS_RESET_UART1 |
+		rp.RESETS_RESET_USBCTRL
+	initDontReset	= rp.RESETS_RESET_IO_QSPI |
+		rp.RESETS_RESET_PADS_QSPI |
+		rp.RESETS_RESET_PLL_USB |
+		rp.RESETS_RESET_USBCTRL |
+		rp.RESETS_RESET_SYSCFG |
+		rp.RESETS_RESET_PLL_SYS
+	padEnableMask	= rp.PADS_BANK0_GPIO0_IE_Msk |
+		rp.PADS_BANK0_GPIO0_OD_Msk
+)
+```
+
+
+
+```go
+const (
+	PinOutput	PinMode	= iota
+	PinInput
+	PinInputPulldown
+	PinInputPullup
+	PinAnalog
+	PinUART
+	PinPWM
+	PinI2C
+	PinSPI
+	PinPIO0
+	PinPIO1
+)
+```
+
+
+
+```go
+const (
+	ADC0	Pin	= GPIO26
+	ADC1	Pin	= GPIO27
+	ADC2	Pin	= GPIO28
+	ADC3	Pin	= GPIO29
+
+	thermADC	= 30
+)
+```
+
+Analog pins on RP2040.
+
+
+```go
+const (
+	// Edge falling
+	PinFalling	PinChange	= 4 << iota
+	// Edge rising
+	PinRising
+
+	PinToggle	= PinFalling | PinRising
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// GPIO pins
+	GPIO0	Pin	= 0	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO1	Pin	= 1	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO2	Pin	= 2	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO3	Pin	= 3	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO4	Pin	= 4	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO5	Pin	= 5	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO6	Pin	= 6	// peripherals: PWM3 channel A, I2C1 SDA
+	GPIO7	Pin	= 7	// peripherals: PWM3 channel B, I2C1 SCL
+	GPIO8	Pin	= 8	// peripherals: PWM4 channel A, I2C0 SDA
+	GPIO9	Pin	= 9	// peripherals: PWM4 channel B, I2C0 SCL
+	GPIO10	Pin	= 10	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO11	Pin	= 11	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO12	Pin	= 12	// peripherals: PWM6 channel A, I2C0 SDA
+	GPIO13	Pin	= 13	// peripherals: PWM6 channel B, I2C0 SCL
+	GPIO14	Pin	= 14	// peripherals: PWM7 channel A, I2C1 SDA
+	GPIO15	Pin	= 15	// peripherals: PWM7 channel B, I2C1 SCL
+	GPIO16	Pin	= 16	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO17	Pin	= 17	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO18	Pin	= 18	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO19	Pin	= 19	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO20	Pin	= 20	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO21	Pin	= 21	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO22	Pin	= 22	// peripherals: PWM3 channel A
+	GPIO23	Pin	= 23	// peripherals: PWM3 channel B
+	GPIO24	Pin	= 24	// peripherals: PWM4 channel A
+	GPIO25	Pin	= 25	// peripherals: PWM4 channel B
+	GPIO26	Pin	= 26	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO27	Pin	= 27	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO28	Pin	= 28	// peripherals: PWM6 channel A
+	GPIO29	Pin	= 29	// peripherals: PWM6 channel B
+)
+```
+
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 8.3s).
+	//
+	// Nominal 1us per watchdog tick, 24-bit counter,
+	// but due to errata two ticks consumed per 1us.
+	// See: Errata RP2040-E1
+	WatchdogMaxTimeout = (rp.WATCHDOG_LOAD_LOAD_Msk / 1000) / 2
+)
+```
+
+
+
+```go
+const XOSC_STARTUP_DELAY_MULTIPLIER = 64
+```
+
+On some boards, the XOSC can take longer than usual to stabilize. On such
+boards, this is needed to avoid a hard fault on boot/reset. Refer to
+PICO_XOSC_STARTUP_DELAY_MULTIPLIER in the Pico SDK for additional details.
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	UART0	= &_UART0
+	_UART0	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART0,
+	}
+
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART1,
+	}
+)
+```
+
+UART on the RP2040
+
+
+```go
+var RTC = (*rtcType)(unsafe.Pointer(rp.RTC))
+```
+
+
+
+```go
+var (
+	ErrRtcDelayTooSmall	= errors.New("RTC interrupt deplay is too small, shall be at least 1 second")
+	ErrRtcDelayTooLarge	= errors.New("RTC interrupt deplay is too large, shall be no more than 1 day")
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	I2C0	= &_I2C0
+	_I2C0	= I2C{
+		Bus: rp.I2C0,
+	}
+	I2C1	= &_I2C1
+	_I2C1	= I2C{
+		Bus: rp.I2C1,
+	}
+)
+```
+
+I2C on the RP2040/RP2350
+
+
+```go
+var (
+	ErrBadPeriod = errors.New("period outside valid range 8ns..268ms")
+)
+```
+
+
+
+```go
+var (
+	PWM0	= getPWMGroup(0)
+	PWM1	= getPWMGroup(1)
+	PWM2	= getPWMGroup(2)
+	PWM3	= getPWMGroup(3)
+	PWM4	= getPWMGroup(4)
+	PWM5	= getPWMGroup(5)
+	PWM6	= getPWMGroup(6)
+	PWM7	= getPWMGroup(7)
+)
+```
+
+Hardware Pulse Width Modulation (PWM) API
+PWM peripherals available on RP2040. Each peripheral has 2 pins available for
+a total of 16 available PWM outputs. Some pins may not be available on some boards.
+
+The RP2040 PWM block has 8 identical slices. Each slice can drive two PWM output signals, or
+measure the frequency or duty cycle of an input signal. This gives a total of up to 16 controllable
+PWM outputs. All 30 GPIOs can be driven by the PWM block
+
+The PWM hardware functions by continuously comparing the input value to a free-running counter. This produces a
+toggling output where the amount of time spent at the high output level is proportional to the input value. The fraction of
+time spent at the high signal level is known as the duty cycle of the signal.
+
+The default behaviour of a PWM slice is to count upward until the wrap value (\ref pwm_config_set_wrap) is reached, and then
+immediately wrap to 0. PWM slices also offer a phase-correct mode, where the counter starts to count downward after
+reaching TOP, until it reaches 0 again.
+
+
+```go
+var (
+	SPI0	= &SPI{
+		Bus: rp.SPI0,
+	}
+	SPI1	= &SPI{
+		Bus: rp.SPI1,
+	}
+)
+```
+
+SPI on the RP2040
+
+
+```go
+var (
+	ErrLSBNotSupported	= errors.New("SPI LSB unsupported on PL022")
+	ErrSPITimeout		= errors.New("SPI timeout")
+	ErrSPIBaud		= errors.New("SPI baud too low or above 66.5Mhz")
+	errSPIInvalidSDI	= errors.New("invalid SPI SDI pin")
+	errSPIInvalidSDO	= errors.New("invalid SPI SDO pin")
+	errSPIInvalidSCK	= errors.New("invalid SPI SCK pin")
+)
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the RP2040.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ChipVersion
+
+```go
+func ChipVersion() uint8
+```
+
+ChipVersion returns the version of the chip. 1 is returned for B0 and B1
+chip.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func CurrentCore
+
+```go
+func CurrentCore() int
+```
+
+CurrentCore returns the core number the call was made from.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of semi-random data based on ring oscillator.
+
+Unlike some other implementations of GetRNG, these random numbers are not
+cryptographically secure and must not be used for cryptographic operations
+(nonces, etc).
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC resets the ADC peripheral.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func NumCores
+
+```go
+func NumCores() int
+```
+
+NumCores returns number of cores available on the device.
+
+
+### func PWMPeripheral
+
+```go
+func PWMPeripheral(pin Pin) (sliceNum uint8, err error)
+```
+
+Peripheral returns the RP2040 PWM peripheral which ranges from 0 to 7. Each
+PWM peripheral has 2 channels, A and B which correspond to 0 and 1 in the program.
+This number corresponds to the package's PWM0 throughout PWM7 handles
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() (millicelsius int32)
+```
+
+ReadTemperature does a one-shot sample of the internal temperature sensor and returns a milli-celsius reading.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig) error
+```
+
+Configure sets the ADC pin to analog input mode.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns a one-shot ADC sample reading.
+
+
+### func (ADC) GetADCChannel
+
+```go
+func (a ADC) GetADCChannel() (c ADCChannel, err error)
+```
+
+GetADCChannel returns the channel associated with the ADC pin.
+
+
+
+
+## type ADCChannel
+
+```go
+type ADCChannel uint8
+```
+
+ADCChannel is the ADC peripheral mux channel. 0-4.
+
+
+
+### func (ADCChannel) Configure
+
+```go
+func (c ADCChannel) Configure(config ADCConfig) error
+```
+
+Configure sets the channel's associated pin to analog input mode.
+The powered on temperature sensor increases ADC_AVDD current by approximately 40 μA.
+
+
+### func (ADCChannel) Pin
+
+```go
+func (c ADCChannel) Pin() (p Pin, err error)
+```
+
+The Pin method returns the GPIO Pin associated with the ADC mux channel, if it has one.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*rp.I2C0_Type
+	mode		I2CMode
+	txInProgress	bool
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure initializes i2c peripheral and configures I2C config's pins passed.
+Here's a list of valid SDA and SCL GPIO pins on bus I2C0 of the rp2040:
+
+	SDA: 0, 4, 8, 12, 16, 20
+	SCL: 1, 5, 9, 13, 17, 21
+
+Same as above for I2C1 bus:
+
+	SDA: 2, 6, 10, 14, 18, 26
+	SCL: 3, 7, 11, 15, 19, 27
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint16) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx performs a write and then a read transfer placing the result in
+in r.
+
+Passing a nil value for w or r skips the transfer corresponding to write
+or read, respectively.
+
+	i2c.Tx(addr, nil, r)
+
+Performs only a read transfer.
+
+	i2c.Tx(addr, w, nil)
+
+Performs only a write transfer.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	// SDA/SCL Serial Data and clock pins. Refer to datasheet to see
+	// which pins match the desired bus.
+	SDA, SCL	Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure configures the gpio pin as per mode.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get reads the pin value.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set drives the pin high if value is true else drives it low.
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+PinChange represents one or more trigger events that can happen on a given GPIO pin
+on the RP2040. ORed PinChanges are valid input to most IRQ functions.
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus *rp.SPI0_Type
+}
+```
+
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup/initialize the SPI interface.
+Default baudrate of 4MHz is used if Frequency == 0. Default
+word length (data bits) is 8.
+Below is a list of GPIO pins corresponding to SPI0 bus on the rp2040:
+
+	SI : 0, 4, 17  a.k.a RX and MISO (if rp2040 is master)
+	SO : 3, 7, 19  a.k.a TX and MOSI (if rp2040 is master)
+	SCK: 2, 6, 18
+
+SPI1 bus GPIO pins:
+
+	SI : 8, 12
+	SO : 11, 15
+	SCK: 10, 14
+
+No pin configuration is needed of SCK, SDO and SDI needed after calling Configure.
+
+
+### func (*SPI) GetBaudRate
+
+```go
+func (spi *SPI) GetBaudRate() uint32
+```
+
+
+
+### func (*SPI) PrintRegs
+
+```go
+func (spi *SPI) PrintRegs()
+```
+
+PrintRegs prints SPI's peripheral common registries current values
+
+
+### func (*SPI) SetBaudRate
+
+```go
+func (spi *SPI) SetBaudRate(br uint32) error
+```
+
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Write a single byte and read a single byte from TX/RX FIFO.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) (err error)
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+Remark: This implementation (RP2040) allows reading into buffer with a custom repeated
+value on tx.
+
+	spi.Tx([]byte{0xff}, rx) // may cause unwanted heap allocations.
+
+This form sends 0xff and puts the result into rx buffer. Useful for reading from SD cards
+which require 0xff input on SI.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	// LSB not supported on rp2040.
+	LSBFirst	bool
+	// Mode's two most LSB are CPOL and CPHA. i.e. Mode==2 (0b10) is CPOL=1, CPHA=0
+	Mode	uint8
+	// Serial clock pin
+	SCK	Pin
+	// TX or Serial Data Out (MOSI if rp2040 is master)
+	SDO	Pin
+	// RX or Serial Data In (MISO if rp2040 is master)
+	SDI	Pin
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*rp.UART0_Type
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the RP2040.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the baudrate to be used for the UART.
+
+
+### func (*UART) SetFormat
+
+```go
+func (uart *UART) SetFormat(databits, stopbits uint8, parity UARTParity) error
+```
+
+SetFormat for number of data bits, stop bits, and parity for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) ClearStallEPIn
+
+```go
+func (dev *USBDevice) ClearStallEPIn(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB IN endpoint.
+
+
+### func (*USBDevice) ClearStallEPOut
+
+```go
+func (dev *USBDevice) ClearStallEPOut(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB OUT endpoint.
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+### func (*USBDevice) SetStallEPIn
+
+```go
+func (dev *USBDevice) SetStallEPIn(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB IN endpoint.
+
+
+### func (*USBDevice) SetStallEPOut
+
+```go
+func (dev *USBDevice) SetStallEPOut(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB OUT endpoint.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/wioterminal.md b/content/docs/reference/microcontrollers/machine/wioterminal.md
new file mode 100644
index 00000000..42ba5990
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/wioterminal.md
@@ -0,0 +1,1976 @@
+
+---
+title: wioterminal
+---
+
+
+## Constants
+
+```go
+const (
+	ADC0	= A0
+	ADC1	= A1
+	ADC2	= A2
+	ADC3	= A3
+	ADC4	= A4
+	ADC5	= A5
+	ADC6	= A6
+	ADC7	= A7
+	ADC8	= A8
+
+	LED	= PIN_LED
+	BUTTON	= BUTTON_1
+)
+```
+
+
+
+```go
+const (
+
+	// LEDs
+	PIN_LED_13	= PA15
+	PIN_LED_RXL	= PA15
+	PIN_LED_TXL	= PA15
+	PIN_LED		= PIN_LED_13
+	PIN_LED2	= PIN_LED_RXL
+	PIN_LED3	= PIN_LED_TXL
+	LED_BUILTIN	= PIN_LED_13
+	PIN_NEOPIXEL	= PA15
+
+	//Digital PINs
+	D0	= PB08
+	D1	= PB09
+	D2	= PA07
+	D3	= PB04
+	D4	= PB05
+	D5	= PB06
+	D6	= PA04
+	D7	= PB07
+	D8	= PA06
+
+	//Analog PINs
+	A0	= PB08	// ADC/AIN[0]
+	A1	= PB09	// ADC/AIN[2]
+	A2	= PA07	// ADC/AIN[3]
+	A3	= PB04	// ADC/AIN[4]
+	A4	= PB05	// ADC/AIN[5]
+	A5	= PB06	// ADC/AIN[10]
+	A6	= PA04	// ADC/AIN[10]
+	A7	= PB07	// ADC/AIN[10]
+	A8	= PA06	// ADC/AIN[10]
+
+	//PIN DEFINE FOR RPI
+	BCM0	= PA13	// I2C Wire1
+	BCM1	= PA12	// I2C Wire1
+	BCM2	= PA17	// I2C Wire2
+	BCM3	= PA16	// I2C Wire2
+	BCM4	= PB14	// GCLK
+	BCM5	= PB12	// GCLK
+	BCM6	= PB13	// GCLK
+	BCM7	= PA05	// DAC1
+	BCM8	= PB01	// SPI SS
+	BCM9	= PB00	// SPI SDI
+	BCM10	= PB02	// SPI SDO
+	BCM11	= PB03	// SPI SCK
+	BCM12	= PB06
+	BCM13	= PA04
+	BCM14	= PB27	// UART Serial1
+	BCM15	= PB26	// UART Serial1
+	BCM16	= PB07
+	BCM17	= PA02	// DAC0
+	BCM18	= PB28	// FPC Digital & AD pins
+	BCM19	= PA20	// WIO_IR
+	BCM20	= PA21	// I2S SDO
+	BCM21	= PA22	// I2S SDI
+	BCM22	= PB09
+	BCM23	= PA07
+	BCM24	= PB04
+	BCM25	= PB05
+	BCM26	= PA06
+	BCM27	= PB08
+
+	// FPC NEW DEFINE
+	FPC1	= PB28	// FPC Digital & AD pins
+	FPC2	= PB17
+	FPC3	= PB29
+	FPC4	= PA14
+	FPC5	= PC01
+	FPC6	= PC02
+	FPC7	= PC03
+	FPC8	= PC04
+	FPC9	= PC31
+	FPC10	= PD00
+
+	// RPI Analog RPIs
+	RPI_A0	= PB08
+	RPI_A1	= PB09
+	RPI_A2	= PA07
+	RPI_A3	= PB04
+	RPI_A4	= PB05
+	RPI_A5	= PB06
+	RPI_A6	= PA04
+	RPI_A7	= PB07
+	RPI_A8	= PA06
+
+	PIN_DAC0	= PA02
+	PIN_DAC1	= PA05
+
+	// USB
+	PIN_USB_DM		= PA24
+	PIN_USB_DP		= PA25
+	PIN_USB_HOST_ENABLE	= PA27
+
+	// BUTTON
+	BUTTON_1	= PC26
+	BUTTON_2	= PC27
+	BUTTON_3	= PC28
+	WIO_KEY_A	= PC26
+	WIO_KEY_B	= PC27
+	WIO_KEY_C	= PC28
+
+	// SWITCH
+	SWITCH_X	= PD20
+	SWITCH_Y	= PD12
+	SWITCH_Z	= PD09
+	SWITCH_B	= PD08
+	SWITCH_U	= PD10
+
+	WIO_5S_UP	= PD20
+	WIO_5S_LEFT	= PD12
+	WIO_5S_RIGHT	= PD09
+	WIO_5S_DOWN	= PD08
+	WIO_5S_PRESS	= PD10
+
+	// IRQ0 : RTL8720D
+	IRQ0	= PC20
+
+	// BUZZER_CTR
+	BUZZER_CTR	= PD11
+	WIO_BUZZER	= PD11
+
+	// MIC_INPUT
+	MIC_INPUT	= PC30
+	WIO_MIC		= PC30
+
+	// GCLK
+	GCLK0	= PB14
+	GCLK1	= PB12
+	GCLK2	= PB13
+
+	// Serial interfaces
+	// Serial1
+	PIN_SERIAL1_RX	= PB27
+	PIN_SERIAL1_TX	= PB26
+
+	// Serial2 : RTL8720D
+	PIN_SERIAL2_RX	= PC23
+	PIN_SERIAL2_TX	= PC22
+
+	// Wire Interfaces
+	// I2C Wire2
+	// I2C1
+	PIN_WIRE_SDA	= PA17
+	PIN_WIRE_SCL	= PA16
+	SDA		= PIN_WIRE_SDA
+	SCL		= PIN_WIRE_SCL
+
+	// I2C Wire1
+	// I2C0 : LIS3DHTR and ATECC608
+	PIN_WIRE1_SDA	= PA13
+	PIN_WIRE1_SCL	= PA12
+
+	SDA1	= PIN_WIRE1_SDA
+	SCL1	= PIN_WIRE1_SCL
+
+	PIN_GYROSCOPE_WIRE_SDA	= PIN_WIRE1_SDA
+	PIN_GYROSCOPE_WIRE_SCL	= PIN_WIRE1_SCL
+	GYROSCOPE_INT1		= PC21
+
+	WIO_LIS3DH_SDA	= PIN_WIRE1_SDA
+	WIO_LIS3DH_SCL	= PIN_WIRE1_SCL
+	WIO_LIS3DH_INT	= PC21
+
+	// SPI
+	PIN_SPI_SDI	= PB00
+	PIN_SPI_SDO	= PB02
+	PIN_SPI_SCK	= PB03
+	PIN_SPI_SS	= PB01
+
+	SS	= PIN_SPI_SS
+	SDO	= PIN_SPI_SDO
+	SDI	= PIN_SPI_SDI
+	SCK	= PIN_SPI_SCK
+
+	// SPI1 RTL8720D_SPI
+	PIN_SPI1_SDI	= PC24
+	PIN_SPI1_SDO	= PB24
+	PIN_SPI1_SCK	= PB25
+	PIN_SPI1_SS	= PC25
+
+	SS1	= PIN_SPI1_SS
+	SDO1	= PIN_SPI1_SDO
+	SDI1	= PIN_SPI1_SDI
+	SCK1	= PIN_SPI1_SCK
+
+	// SPI2 SD_SPI
+	PIN_SPI2_SDI	= PC18
+	PIN_SPI2_SDO	= PC16
+	PIN_SPI2_SCK	= PC17
+	PIN_SPI2_SS	= PC19
+
+	SS2	= PIN_SPI2_SS
+	SDO2	= PIN_SPI2_SDO
+	SDI2	= PIN_SPI2_SDI
+	SCK2	= PIN_SPI2_SCK
+
+	// SPI3 LCD_SPI
+	PIN_SPI3_SDI	= PB18
+	PIN_SPI3_SDO	= PB19
+	PIN_SPI3_SCK	= PB20
+	PIN_SPI3_SS	= PB21
+
+	SS3	= PIN_SPI3_SS
+	SDO3	= PIN_SPI3_SDO
+	SDI3	= PIN_SPI3_SDI
+	SCK3	= PIN_SPI3_SCK
+
+	// Needed for SD library
+	SDCARD_SDI_PIN	= PIN_SPI2_SDI
+	SDCARD_SDO_PIN	= PIN_SPI2_SDO
+	SDCARD_SCK_PIN	= PIN_SPI2_SCK
+	SDCARD_SS_PIN	= PIN_SPI2_SS
+	SDCARD_DET_PIN	= PD21
+
+	LCD_SDI_PIN	= PIN_SPI3_SDI
+	LCD_SDO_PIN	= PIN_SPI3_SDO
+	LCD_SCK_PIN	= PIN_SPI3_SCK
+	LCD_SS_PIN	= PIN_SPI3_SS
+	LCD_DC		= PC06
+	LCD_RESET	= PC07
+	LCD_BACKLIGHT	= PC05
+
+	// 4 WIRE LCD TOUCH
+	LCD_XL	= PC10
+	LCD_YU	= PC11
+	LCD_XR	= PC12
+	LCD_YD	= PC13
+
+	// Needed for RTL8720D
+	RTL8720D_SDI_PIN	= PIN_SPI1_SDI
+	RTL8720D_SDO_PIN	= PIN_SPI1_SDO
+	RTL8720D_SCK_PIN	= PIN_SPI1_SCK
+	RTL8720D_SS_PIN		= PIN_SPI1_SS
+
+	//QSPI Pins
+	PIN_QSPI_IO0	= PA08
+	PIN_QSPI_IO1	= PA09
+	PIN_QSPI_IO2	= PA10
+	PIN_QSPI_IO3	= PA11
+	PIN_QSPI_SCK	= PB10
+	PIN_QSPI_CS	= PB11
+
+	// I2S Interfaces
+	PIN_I2S_FS	= PA20
+	PIN_I2S_SCK	= PB16
+	PIN_I2S_SDO	= PA22
+	PIN_I2S_SDI	= PA21
+
+	I2S_LRCLK	= PA20
+	I2S_BLCK	= PB16
+	I2S_SDOUT	= PA22
+	I2S_SDIN	= PA21
+
+	// RTL8720D Interfaces
+	RTL8720D_CHIP_PU	= PA18
+	RTL8720D_GPIO0		= PA19	// SYNC
+
+	// SWD
+	SWDCLK	= PA30
+	SWDIO	= PA31
+	SWO	= PB30
+
+	// light sensor
+	WIO_LIGHT	= PD01
+
+	// ir sensor
+	WIO_IR	= PB31
+
+	// OUTPUT_CTR
+	OUTPUT_CTR_5V	= PC14
+	OUTPUT_CTR_3V3	= PC15
+)
+```
+
+
+
+```go
+const (
+	USBCDC_DM_PIN	= PIN_USB_DM
+	USBCDC_DP_PIN	= PIN_USB_DP
+)
+```
+
+USBCDC pins
+
+
+```go
+const (
+	UART_TX_PIN	= PIN_SERIAL1_TX
+	UART_RX_PIN	= PIN_SERIAL1_RX
+)
+```
+
+UART1 pins
+
+
+```go
+const (
+	UART2_TX_PIN	= PIN_SERIAL2_TX
+	UART2_RX_PIN	= PIN_SERIAL2_RX
+)
+```
+
+UART2 pins RTL8720D
+
+
+```go
+const (
+	SDA1_PIN	= PA17	// SDA: SERCOM3/PAD[0]
+	SCL1_PIN	= PA16	// SCL: SERCOM3/PAD[1]
+
+	SDA0_PIN	= PA13	// SDA: SERCOM4/PAD[0]
+	SCL0_PIN	= PA12	// SCL: SERCOM4/PAD[1]
+
+	SDA_PIN	= SDA1_PIN
+	SCL_PIN	= SCL1_PIN
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	I2S_SCK_PIN	= BCM18
+	I2S_SDO_PIN	= BCM21
+	I2S_SDI_PIN	= BCM20
+	I2S_WS_PIN	= BCM19
+)
+```
+
+I2S pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= SCK	// SCK:  SERCOM5/PAD[1]
+	SPI0_SDO_PIN	= SDO	// SDO: SERCOM5/PAD[0]
+	SPI0_SDI_PIN	= SDI	// SDI: SERCOM5/PAD[2]
+
+	// RTL8720D
+	SPI1_SCK_PIN	= SCK1	// SCK:  SERCOM0/PAD[1]
+	SPI1_SDO_PIN	= SDO1	// SDO: SERCOM0/PAD[0]
+	SPI1_SDI_PIN	= SDI1	// SDI: SERCOM0/PAD[2]
+
+	// SD
+	SPI2_SCK_PIN	= SCK2	// SCK:  SERCOM6/PAD[1]
+	SPI2_SDO_PIN	= SDO2	// SDO: SERCOM6/PAD[0]
+	SPI2_SDI_PIN	= SDI2	// SDI: SERCOM6/PAD[2]
+
+	// LCD
+	SPI3_SCK_PIN	= SCK3	// SCK:  SERCOM7/PAD[1]
+	SPI3_SDO_PIN	= SDO3	// SDO: SERCOM7/PAD[3]
+	SPI3_SDI_PIN	= SDI3	// SDI: SERCOM7/PAD[2]
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinAnalog		PinMode	= 1
+	PinSERCOM		PinMode	= 2
+	PinSERCOMAlt		PinMode	= 3
+	PinTimer		PinMode	= 4
+	PinTimerAlt		PinMode	= 5
+	PinTCCPDEC		PinMode	= 6
+	PinCom			PinMode	= 7
+	PinSDHC			PinMode	= 8
+	PinI2S			PinMode	= 9
+	PinPCC			PinMode	= 10
+	PinGMAC			PinMode	= 11
+	PinACCLK		PinMode	= 12
+	PinCCL			PinMode	= 13
+	PinDigital		PinMode	= 14
+	PinInput		PinMode	= 15
+	PinInputPullup		PinMode	= 16
+	PinOutput		PinMode	= 17
+	PinTCCE			PinMode	= PinTimer
+	PinTCCF			PinMode	= PinTimerAlt
+	PinTCCG			PinMode	= PinTCCPDEC
+	PinInputPulldown	PinMode	= 18
+	PinCAN			PinMode	= 19
+	PinCAN0			PinMode	= PinSDHC
+	PinCAN1			PinMode	= PinCom
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
+	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
+	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	PA00	Pin	= 0
+	PA01	Pin	= 1
+	PA02	Pin	= 2
+	PA03	Pin	= 3
+	PA04	Pin	= 4
+	PA05	Pin	= 5
+	PA06	Pin	= 6
+	PA07	Pin	= 7
+	PA08	Pin	= 8	// peripherals: TCC0 channel 0, TCC1 channel 4, sercomI2CM0 SDA, sercomI2CM2 SDA
+	PA09	Pin	= 9	// peripherals: TCC0 channel 1, TCC1 channel 5, sercomI2CM0 SCL, sercomI2CM2 SCL
+	PA10	Pin	= 10	// peripherals: TCC0 channel 2, TCC1 channel 6
+	PA11	Pin	= 11	// peripherals: TCC0 channel 3, TCC1 channel 7
+	PA12	Pin	= 12	// peripherals: TCC0 channel 6, TCC1 channel 2, sercomI2CM2 SDA, sercomI2CM4 SDA
+	PA13	Pin	= 13	// peripherals: TCC0 channel 7, TCC1 channel 3, sercomI2CM2 SCL, sercomI2CM4 SCL
+	PA14	Pin	= 14	// peripherals: TCC2 channel 0, TCC1 channel 2
+	PA15	Pin	= 15	// peripherals: TCC2 channel 1, TCC1 channel 3
+	PA16	Pin	= 16	// peripherals: TCC1 channel 0, TCC0 channel 4, sercomI2CM1 SDA, sercomI2CM3 SDA
+	PA17	Pin	= 17	// peripherals: TCC1 channel 1, TCC0 channel 5, sercomI2CM1 SCL, sercomI2CM3 SCL
+	PA18	Pin	= 18	// peripherals: TCC1 channel 2, TCC0 channel 6
+	PA19	Pin	= 19	// peripherals: TCC1 channel 3, TCC0 channel 7
+	PA20	Pin	= 20	// peripherals: TCC1 channel 4, TCC0 channel 0
+	PA21	Pin	= 21	// peripherals: TCC1 channel 5, TCC0 channel 1
+	PA22	Pin	= 22	// peripherals: TCC1 channel 6, TCC0 channel 2, sercomI2CM3 SDA, sercomI2CM5 SDA
+	PA23	Pin	= 23	// peripherals: TCC1 channel 7, TCC0 channel 3, sercomI2CM3 SCL, sercomI2CM5 SCL
+	PA24	Pin	= 24	// peripherals: TCC2 channel 2
+	PA25	Pin	= 25	// peripherals: TCC2 channel 3
+	PA26	Pin	= 26
+	PA27	Pin	= 27
+	PA28	Pin	= 28
+	PA29	Pin	= 29
+	PA30	Pin	= 30	// peripherals: TCC2 channel 0
+	PA31	Pin	= 31	// peripherals: TCC2 channel 1
+	PB00	Pin	= 32
+	PB01	Pin	= 33
+	PB02	Pin	= 34	// peripherals: TCC2 channel 2
+	PB03	Pin	= 35	// peripherals: TCC2 channel 3
+	PB04	Pin	= 36
+	PB05	Pin	= 37
+	PB06	Pin	= 38
+	PB07	Pin	= 39
+	PB08	Pin	= 40
+	PB09	Pin	= 41
+	PB10	Pin	= 42	// peripherals: TCC0 channel 4, TCC1 channel 0
+	PB11	Pin	= 43	// peripherals: TCC0 channel 5, TCC1 channel 1
+	PB12	Pin	= 44	// peripherals: TCC3 channel 0, TCC0 channel 0
+	PB13	Pin	= 45	// peripherals: TCC3 channel 1, TCC0 channel 1
+	PB14	Pin	= 46	// peripherals: TCC4 channel 0, TCC0 channel 2
+	PB15	Pin	= 47	// peripherals: TCC4 channel 1, TCC0 channel 3
+	PB16	Pin	= 48	// peripherals: TCC3 channel 0, TCC0 channel 4
+	PB17	Pin	= 49	// peripherals: TCC3 channel 1, TCC0 channel 5
+	PB18	Pin	= 50	// peripherals: TCC1 channel 0
+	PB19	Pin	= 51	// peripherals: TCC1 channel 1
+	PB20	Pin	= 52	// peripherals: TCC1 channel 2
+	PB21	Pin	= 53	// peripherals: TCC1 channel 3
+	PB22	Pin	= 54
+	PB23	Pin	= 55
+	PB24	Pin	= 56
+	PB25	Pin	= 57
+	PB26	Pin	= 58	// peripherals: TCC1 channel 2
+	PB27	Pin	= 59	// peripherals: TCC1 channel 3
+	PB28	Pin	= 60	// peripherals: TCC1 channel 4
+	PB29	Pin	= 61	// peripherals: TCC1 channel 5
+	PB30	Pin	= 62	// peripherals: TCC4 channel 0, TCC0 channel 6
+	PB31	Pin	= 63	// peripherals: TCC4 channel 1, TCC0 channel 7
+	PC00	Pin	= 64
+	PC01	Pin	= 65
+	PC02	Pin	= 66
+	PC03	Pin	= 67
+	PC04	Pin	= 68	// peripherals: TCC0 channel 0
+	PC05	Pin	= 69	// peripherals: TCC0 channel 1
+	PC06	Pin	= 70
+	PC07	Pin	= 71
+	PC08	Pin	= 72
+	PC09	Pin	= 73
+	PC10	Pin	= 74	// peripherals: TCC0 channel 0, TCC1 channel 4
+	PC11	Pin	= 75	// peripherals: TCC0 channel 1, TCC1 channel 5
+	PC12	Pin	= 76	// peripherals: TCC0 channel 2, TCC1 channel 6
+	PC13	Pin	= 77	// peripherals: TCC0 channel 3, TCC1 channel 7
+	PC14	Pin	= 78	// peripherals: TCC0 channel 4, TCC1 channel 0
+	PC15	Pin	= 79	// peripherals: TCC0 channel 5, TCC1 channel 1
+	PC16	Pin	= 80	// peripherals: TCC0 channel 0
+	PC17	Pin	= 81	// peripherals: TCC0 channel 1
+	PC18	Pin	= 82	// peripherals: TCC0 channel 2
+	PC19	Pin	= 83	// peripherals: TCC0 channel 3
+	PC20	Pin	= 84	// peripherals: TCC0 channel 4
+	PC21	Pin	= 85	// peripherals: TCC0 channel 5
+	PC22	Pin	= 86	// peripherals: TCC0 channel 6
+	PC23	Pin	= 87	// peripherals: TCC0 channel 7
+	PC24	Pin	= 88
+	PC25	Pin	= 89
+	PC26	Pin	= 90
+	PC27	Pin	= 91
+	PC28	Pin	= 92
+	PC29	Pin	= 93
+	PC30	Pin	= 94
+	PC31	Pin	= 95
+	PD00	Pin	= 96
+	PD01	Pin	= 97
+	PD02	Pin	= 98
+	PD03	Pin	= 99
+	PD04	Pin	= 100
+	PD05	Pin	= 101
+	PD06	Pin	= 102
+	PD07	Pin	= 103
+	PD08	Pin	= 104	// peripherals: TCC0 channel 1, sercomI2CM6 SDA, sercomI2CM7 SDA
+	PD09	Pin	= 105	// peripherals: TCC0 channel 2, sercomI2CM6 SCL, sercomI2CM7 SCL
+	PD10	Pin	= 106	// peripherals: TCC0 channel 3
+	PD11	Pin	= 107	// peripherals: TCC0 channel 4
+	PD12	Pin	= 108	// peripherals: TCC0 channel 5
+	PD13	Pin	= 109	// peripherals: TCC0 channel 6
+	PD14	Pin	= 110
+	PD15	Pin	= 111
+	PD16	Pin	= 112
+	PD17	Pin	= 113
+	PD18	Pin	= 114
+	PD19	Pin	= 115
+	PD20	Pin	= 116	// peripherals: TCC1 channel 0
+	PD21	Pin	= 117	// peripherals: TCC1 channel 1
+	PD22	Pin	= 118
+	PD23	Pin	= 119
+	PD24	Pin	= 120
+	PD25	Pin	= 121
+	PD26	Pin	= 122
+	PD27	Pin	= 123
+	PD28	Pin	= 124
+	PD29	Pin	= 125
+	PD30	Pin	= 126
+	PD31	Pin	= 127
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	// SERCOM_FREQ_REF is always reference frequency on SAMD51 regardless of CPU speed.
+	SERCOM_FREQ_REF		= 48000000
+	SERCOM_FREQ_REF_GCLK0	= 120000000
+
+	// Default rise time in nanoseconds, based on 4.7K ohm pull up resistors
+	riseTimeNanoseconds	= 125
+
+	// wire bus states
+	wireUnknownState	= 0
+	wireIdleState		= 1
+	wireOwnerState		= 2
+	wireBusyState		= 3
+
+	// wire commands
+	wireCmdNoAction		= 0
+	wireCmdRepeatStart	= 1
+	wireCmdRead		= 2
+	wireCmdStop		= 3
+)
+```
+
+
+
+```go
+const (
+	QSPI_SCK	= PB10
+	QSPI_CS		= PB11
+	QSPI_DATA0	= PA08
+	QSPI_DATA1	= PA09
+	QSPI_DATA2	= PA10
+	QSPI_DATA3	= PA11
+)
+```
+
+The QSPI peripheral on ATSAMD51 is only available on the following pins
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (16s)
+	WatchdogMaxTimeout = (16384 * 1000) / 1024	// CYC16384/1024kHz
+)
+```
+
+
+
+```go
+const (
+	// these are SAMD51 specific.
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Pos	= 0
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Mask	= 0x3FFF
+
+	usb_DEVICE_PCKSIZE_SIZE_Pos	= 28
+	usb_DEVICE_PCKSIZE_SIZE_Mask	= 0x7
+
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Pos	= 14
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Mask	= 0x3FFF
+
+	NumberOfUSBEndpoints	= 8
+)
+```
+
+
+
+```go
+const HSRAM_SIZE = 0x00030000
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	DefaultUART	= UART1
+
+	UART1	= &sercomUSART2
+
+	// RTL8720D (tx: PC22, rx: PC23)
+	UART2	= &sercomUSART1
+
+	// RTL8720D (tx: PB24, rx: PC24)
+	UART3	= &sercomUSART0
+
+	// Right-hand grove port (tx: D0, rx: D1)
+	UART4	= &sercomUSART4
+)
+```
+
+
+
+```go
+var (
+	I2C0	= sercomI2CM4
+	I2C1	= sercomI2CM3
+)
+```
+
+I2C on the Wio Terminal
+
+
+```go
+var (
+	SPI0	= sercomSPIM5
+
+	// RTL8720D
+	SPI1	= sercomSPIM0
+
+	// SD
+	SPI2	= sercomSPIM6
+
+	// LCD
+	SPI3	= sercomSPIM7
+)
+```
+
+SPI on the Wio Terminal
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	DAC0	= DAC{Channel: 0}
+	DAC1	= DAC{Channel: 1}
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the SAMD51.
+
+
+```go
+var (
+	TCC0	= (*TCC)(sam.TCC0)
+	TCC1	= (*TCC)(sam.TCC1)
+	TCC2	= (*TCC)(sam.TCC2)
+	TCC3	= (*TCC)(sam.TCC3)
+	TCC4	= (*TCC)(sam.TCC4)
+)
+```
+
+This chip has five TCC peripherals, which have PWM as one feature.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) and 16 bytes (128 bits) are common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of cryptographically secure random data
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig)
+```
+
+Configure configures a ADCPin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type DAC
+
+```go
+type DAC struct {
+	Channel uint8
+}
+```
+
+DAC on the SAMD51.
+
+
+
+### func (DAC) Configure
+
+```go
+func (dac DAC) Configure(config DACConfig)
+```
+
+Configure the DAC.
+output pin must already be configured.
+
+
+### func (DAC) Set
+
+```go
+func (dac DAC) Set(value uint16) error
+```
+
+Set writes a single 16-bit value to the DAC.
+Since the ATSAMD51 only has a 12-bit DAC, the passed-in value will be scaled down.
+
+
+
+
+## type DACConfig
+
+```go
+type DACConfig struct {
+}
+```
+
+DACConfig placeholder for future expansion.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*sam.SERCOM_I2CM_Type
+	SERCOM	uint8
+}
+```
+
+I2C on the SAMD51.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteByte
+
+```go
+func (i2c *I2C) WriteByte(data byte) error
+```
+
+WriteByte writes a single byte to the I2C bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when configured as an input or as
+an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+### func (Pin) Toggle
+
+```go
+func (p Pin) Toggle()
+```
+
+Toggle switches an output pin from low to high or from high to low.
+Warning: only use this on an output pin!
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*sam.SERCOM_SPIM_Type
+	SERCOM	uint8
+}
+```
+
+SPI
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type TCC
+
+```go
+type TCC sam.TCC_Type
+```
+
+TCC is one timer peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this timer peripheral at
+once.
+
+
+
+### func (*TCC) Channel
+
+```go
+func (tcc *TCC) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin. Note that one channel may be
+shared between multiple pins, and so will have the same duty cycle. If this
+is not desirable, look for a different TCC or consider using a different pin.
+
+
+### func (*TCC) Configure
+
+```go
+func (tcc *TCC) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this TCC.
+
+
+### func (*TCC) Counter
+
+```go
+func (tcc *TCC) Counter() uint32
+```
+
+Counter returns the current counter value of the timer in this TCC
+peripheral. It may be useful for debugging.
+
+
+### func (*TCC) Set
+
+```go
+func (tcc *TCC) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle, in other words the fraction of time the channel output is high (or low
+when inverted). For example, to set it to a 25% duty cycle, use:
+
+	tcc.Set(channel, tcc.Top() / 4)
+
+tcc.Set(channel, 0) will set the output to low and tcc.Set(channel,
+tcc.Top()) will set the output to high, assuming the output isn't inverted.
+
+
+### func (*TCC) SetInverting
+
+```go
+func (tcc *TCC) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TCC) SetPeriod
+
+```go
+func (tcc *TCC) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this TCC peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the TCC peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TCC) Top
+
+```go
+func (tcc *TCC) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+tcc.Set (see tcc.Set for more information).
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*sam.SERCOM_USART_INT_Type
+	SERCOM		uint8
+	Interrupt	interrupt.Interrupt	// RXC interrupt
+}
+```
+
+UART on the SAMD51.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/x9pro.md b/content/docs/reference/microcontrollers/machine/x9pro.md
new file mode 100644
index 00000000..aa3fe592
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/x9pro.md
@@ -0,0 +1,1204 @@
+
+---
+title: x9pro
+---
+
+
+## Constants
+
+```go
+const (
+	LED		Pin	= 4	// HR LED pin
+	UART_TX_PIN	Pin	= NoPin
+	UART_RX_PIN	Pin	= NoPin
+	SCL_PIN		Pin	= NoPin
+	SDA_PIN		Pin	= NoPin
+	SPI0_SCK_PIN	Pin	= 18
+	SPI0_SDI_PIN	Pin	= 19
+	SPI0_SDO_PIN	Pin	= 20
+)
+```
+
+https://hackaday.io/project/144350-hacking-wearables-for-mental-health-and-more/details
+
+
+```go
+const (
+	OLED_CS		Pin	= 15	// chip select
+	OLED_RES	Pin	= 14	// reset pin
+	OLED_DC		Pin	= 13	// data/command
+	OLED_SCK	Pin	= 12	// SPI clock
+	OLED_SDO	Pin	= 11	// SPI SDO (chip-out, peripheral-in)
+	OLED_LED_POW	Pin	= 16
+	OLED_IC_POW	Pin	= 17
+)
+```
+
+LCD pins.
+
+
+```go
+const HasLowFrequencyCrystal = true
+```
+
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
+	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
+	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	P0_00	Pin	= 0
+	P0_01	Pin	= 1
+	P0_02	Pin	= 2
+	P0_03	Pin	= 3
+	P0_04	Pin	= 4
+	P0_05	Pin	= 5
+	P0_06	Pin	= 6
+	P0_07	Pin	= 7
+	P0_08	Pin	= 8
+	P0_09	Pin	= 9
+	P0_10	Pin	= 10
+	P0_11	Pin	= 11
+	P0_12	Pin	= 12
+	P0_13	Pin	= 13
+	P0_14	Pin	= 14
+	P0_15	Pin	= 15
+	P0_16	Pin	= 16
+	P0_17	Pin	= 17
+	P0_18	Pin	= 18
+	P0_19	Pin	= 19
+	P0_20	Pin	= 20
+	P0_21	Pin	= 21
+	P0_22	Pin	= 22
+	P0_23	Pin	= 23
+	P0_24	Pin	= 24
+	P0_25	Pin	= 25
+	P0_26	Pin	= 26
+	P0_27	Pin	= 27
+	P0_28	Pin	= 28
+	P0_29	Pin	= 29
+	P0_30	Pin	= 30
+	P0_31	Pin	= 31
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	// UART0 is the hardware UART on the NRF SoC.
+	_UART0	= UART{Buffer: NewRingBuffer()}
+	UART0	= &_UART0
+)
+```
+
+UART
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	PWM0	= &PWM{PWM: nrf.PWM0}
+	PWM1	= &PWM{PWM: nrf.PWM1}
+	PWM2	= &PWM{PWM: nrf.PWM2}
+)
+```
+
+PWM
+
+
+```go
+var (
+	SPI0	= &SPI{Bus: nrf.SPIM0, buf: new([1]byte)}
+	SPI1	= &SPI{Bus: nrf.SPIM1, buf: new([1]byte)}
+	SPI2	= &SPI{Bus: nrf.SPIM2, buf: new([1]byte)}
+)
+```
+
+There are 3 SPI interfaces on the NRF528xx.
+
+
+```go
+var (
+	I2C0	= &I2C{Bus: nrf.TWI0}
+	I2C1	= &I2C{Bus: nrf.TWI1}
+)
+```
+
+There are 2 I2C interfaces on the NRF.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial = DefaultUART
+```
+
+Serial is implemented via the default (usually the first) UART on the chip.
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (ret uint32, err error)
+```
+
+GetRNG returns 32 bits of non-deterministic random data based on internal thermal noise.
+According to Nordic's documentation, the random output is suitable for cryptographic purposes.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() int32
+```
+
+ReadTemperature reads the silicon die temperature of the chip. The return
+value is in milli-celsius.
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (*ADC) Configure
+
+```go
+func (a *ADC) Configure(config ADCConfig)
+```
+
+Configure configures an ADC pin to be able to read analog data.
+Reference voltage can be 150, 300, 600, 1200, 1800, 2400, 3000(default), 3600 mV
+Resolution can be 8, 10, 12(default), 14 bits
+SampleTime will be ceiled to 3(default), 5, 10, 15, 20 or 40(max) µS respectively
+Samples can be 1(default), 2, 4, 8, 16, 32, 64, 128, 256 samples
+
+
+### func (*ADC) Get
+
+```go
+func (a *ADC) Get() uint16
+```
+
+Get returns the current value of an ADC pin in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*nrf.TWI_Type
+	mode	I2CMode
+}
+```
+
+I2C on the NRF51 and NRF52.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) (err error)
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWM
+
+```go
+type PWM struct {
+	PWM	*nrf.PWM_Type
+
+	channelValues	[4]volatile.Register16
+}
+```
+
+PWM is one PWM peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this PWM peripheral at
+once.
+
+
+
+### func (*PWM) Channel
+
+```go
+func (pwm *PWM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*PWM) Configure
+
+```go
+func (pwm *PWM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+On the nRF52 series, the maximum period is around 0.26s.
+
+
+### func (*PWM) Set
+
+```go
+func (pwm *PWM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	ch.Set(ch.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*PWM) SetInverting
+
+```go
+func (pwm *PWM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*PWM) SetPeriod
+
+```go
+func (pwm *PWM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*PWM) Top
+
+```go
+func (pwm *PWM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*nrf.SPIM_Type
+	buf	*[1]byte	// 1-byte buffer for the Transfer method
+}
+```
+
+SPI on the NRF.
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to set up the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous
+write/read interface, there must always be the same number of bytes written
+as bytes read. Therefore, if the number of bytes don't match it will be
+padded until they fit: if len(w) > len(r) the extra bytes received will be
+dropped and if len(w) < len(r) extra 0 bytes will be sent.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer *RingBuffer
+}
+```
+
+UART on the NRF.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/xiao-ble.md b/content/docs/reference/microcontrollers/machine/xiao-ble.md
new file mode 100644
index 00000000..b170604d
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/xiao-ble.md
@@ -0,0 +1,1557 @@
+
+---
+title: xiao-ble
+---
+
+
+## Constants
+
+```go
+const (
+	P0_00	Pin	= 0
+	P0_01	Pin	= 1
+	P0_02	Pin	= 2
+	P0_03	Pin	= 3
+	P0_04	Pin	= 4
+	P0_05	Pin	= 5
+	P0_06	Pin	= 6
+	P0_07	Pin	= 7
+	P0_08	Pin	= 8
+	P0_09	Pin	= 9
+	P0_10	Pin	= 10
+	P0_11	Pin	= 11
+	P0_12	Pin	= 12
+	P0_13	Pin	= 13
+	P0_14	Pin	= 14
+	P0_15	Pin	= 15
+	P0_16	Pin	= 16
+	P0_17	Pin	= 17
+	P0_18	Pin	= 18
+	P0_19	Pin	= 19
+	P0_20	Pin	= 20
+	P0_21	Pin	= 21
+	P0_22	Pin	= 22
+	P0_23	Pin	= 23
+	P0_24	Pin	= 24
+	P0_25	Pin	= 25
+	P0_26	Pin	= 26
+	P0_27	Pin	= 27
+	P0_28	Pin	= 28
+	P0_29	Pin	= 29
+	P0_30	Pin	= 30
+	P0_31	Pin	= 31
+	P1_00	Pin	= 32
+	P1_01	Pin	= 33
+	P1_02	Pin	= 34
+	P1_03	Pin	= 35
+	P1_04	Pin	= 36
+	P1_05	Pin	= 37
+	P1_06	Pin	= 38
+	P1_07	Pin	= 39
+	P1_08	Pin	= 40
+	P1_09	Pin	= 41
+	P1_10	Pin	= 42
+	P1_11	Pin	= 43
+	P1_12	Pin	= 44
+	P1_13	Pin	= 45
+	P1_14	Pin	= 46
+	P1_15	Pin	= 47
+)
+```
+
+Hardware pins
+
+
+```go
+const HasLowFrequencyCrystal = true
+```
+
+
+
+```go
+const (
+	D0	Pin	= P0_02
+	D1	Pin	= P0_03
+	D2	Pin	= P0_28
+	D3	Pin	= P0_29
+	D4	Pin	= P0_04
+	D5	Pin	= P0_05
+	D6	Pin	= P1_11
+	D7	Pin	= P1_12
+	D8	Pin	= P1_13
+	D9	Pin	= P1_14
+	D10	Pin	= P1_15
+)
+```
+
+Digital Pins
+
+
+```go
+const (
+	A0	Pin	= P0_02
+	A1	Pin	= P0_03
+	A2	Pin	= P0_28
+	A3	Pin	= P0_29
+	A4	Pin	= P0_04
+	A5	Pin	= P0_05
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	LED		= LED_CHG
+	LED1		= LED_RED
+	LED2		= LED_GREEN
+	LED3		= LED_BLUE
+	LED_CHG		= P0_17
+	LED_RED		= P0_26
+	LED_GREEN	= P0_30
+	LED_BLUE	= P0_06
+)
+```
+
+Onboard LEDs
+
+
+```go
+const (
+	UART_RX_PIN	= P1_12
+	UART_TX_PIN	= P1_11
+)
+```
+
+UART0 pins
+
+
+```go
+const (
+	// Defaults to internal
+	SDA_PIN	= SDA1_PIN
+	SCL_PIN	= SCL1_PIN
+
+	// I2C0 (external) pins
+	SDA0_PIN	= P0_04
+	SCL0_PIN	= P0_05
+
+	// I2C1 (internal) pins
+	SDA1_PIN	= P0_07
+	SCL1_PIN	= P0_27
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= P1_13
+	SPI0_SDO_PIN	= P1_14
+	SPI0_SDI_PIN	= P1_15
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	LSM_PWR	= P1_08	// IMU (LSM6DS3TR) power
+	LSM_INT	= P0_11	// IMU (LSM6DS3TR) interrupt
+
+	MIC_PWR	= P1_10	// Microphone (MSM261D3526H1CPM) power
+	MIC_CLK	= P1_00
+	MIC_DIN	= P0_16
+)
+```
+
+Peripherals
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
+	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
+	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
+	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 36h)
+	WatchdogMaxTimeout = (0xffffffff * 1000) / 32768
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var (
+	DefaultUART = UART0
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	// UART0 is the hardware UART on the NRF SoC.
+	_UART0	= UART{Buffer: NewRingBuffer()}
+	UART0	= &_UART0
+)
+```
+
+UART
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	PWM0	= &PWM{PWM: nrf.PWM0}
+	PWM1	= &PWM{PWM: nrf.PWM1}
+	PWM2	= &PWM{PWM: nrf.PWM2}
+	PWM3	= &PWM{PWM: nrf.PWM3}
+)
+```
+
+PWM
+
+
+```go
+var (
+	I2C0	= &I2C{Bus: nrf.TWIM0, BusT: nrf.TWIS0}
+	I2C1	= &I2C{Bus: nrf.TWIM1, BusT: nrf.TWIS1}
+)
+```
+
+There are 2 I2C interfaces on the NRF.
+
+
+```go
+var (
+	Watchdog = &watchdogImpl{}
+)
+```
+
+
+
+```go
+var (
+	SPI0	= &SPI{Bus: nrf.SPIM0, buf: new([1]byte)}
+	SPI1	= &SPI{Bus: nrf.SPIM1, buf: new([1]byte)}
+	SPI2	= &SPI{Bus: nrf.SPIM2, buf: new([1]byte)}
+)
+```
+
+There are 3 SPI interfaces on the NRF528xx.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader resets the chip into the UF2 bootloader. After reset, it
+can be flashed via nrfutil or by copying a UF2 file to the mass storage device
+
+
+### func EnterOTABootloader
+
+```go
+func EnterOTABootloader()
+```
+
+EnterOTABootloader resets the chip into the bootloader so that it can be
+flashed via an OTA update
+
+
+### func EnterSerialBootloader
+
+```go
+func EnterSerialBootloader()
+```
+
+EnterSerialBootloader resets the chip into the serial bootloader. After
+reset, it can be flashed using serial/nrfutil.
+
+
+### func EnterUF2Bootloader
+
+```go
+func EnterUF2Bootloader()
+```
+
+EnterUF2Bootloader resets the chip into the UF2 bootloader. After reset, it
+can be flashed via nrfutil or by copying a UF2 file to the mass storage device
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (ret uint32, err error)
+```
+
+GetRNG returns 32 bits of non-deterministic random data based on internal thermal noise.
+According to Nordic's documentation, the random output is suitable for cryptographic purposes.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the registers needed for ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() int32
+```
+
+ReadTemperature reads the silicon die temperature of the chip. The return
+value is in milli-celsius.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USBHID (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (*ADC) Configure
+
+```go
+func (a *ADC) Configure(config ADCConfig)
+```
+
+Configure configures an ADC pin to be able to read analog data.
+Reference voltage can be 150, 300, 600, 1200, 1800, 2400, 3000(default), 3600 mV
+Resolution can be 8, 10, 12(default), 14 bits
+SampleTime will be ceiled to 3(default), 5, 10, 15, 20 or 40(max) µS respectively
+Samples can be 1(default), 2, 4, 8, 16, 32, 64, 128, 256 samples
+
+
+### func (*ADC) Get
+
+```go
+func (a *ADC) Get() uint16
+```
+
+Get returns the current value of an ADC pin in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*nrf.TWIM_Type	// Called Bus to align with Bus field in nrf51
+	BusT	*nrf.TWIS_Type
+	mode	I2CMode
+}
+```
+
+I2C on the NRF528xx.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint8) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+Reply supplies the response data the controller.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) (err error)
+```
+
+Tx does a single I2C transaction at the specified address (when in controller mode).
+
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+WaitForEvent blocks the current go-routine until an I2C event is received (when in Target mode).
+
+The passed buffer will be populated for receive events, with the number of bytes
+received returned in count.  For other event types, buf is not modified and a count
+of zero is returned.
+
+For request events, the caller MUST call `Reply` to avoid hanging the i2c bus indefinitely.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDM
+
+```go
+type PDM struct {
+	device		*nrf.PDM_Type
+	defaultBuffer	int16
+}
+```
+
+PDM represents a PDM device
+
+
+
+### func (*PDM) Configure
+
+```go
+func (pdm *PDM) Configure(config PDMConfig) error
+```
+
+Configure is intended to set up the PDM interface prior to use.
+
+
+### func (*PDM) Read
+
+```go
+func (pdm *PDM) Read(buf []int16) (uint32, error)
+```
+
+Read stores a set of samples in the given target buffer.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWM
+
+```go
+type PWM struct {
+	PWM	*nrf.PWM_Type
+
+	channelValues	[4]volatile.Register16
+}
+```
+
+PWM is one PWM peripheral, which consists of a counter and multiple output
+channels (that can be connected to actual pins). You can set the frequency
+using SetPeriod, but only for all the channels in this PWM peripheral at
+once.
+
+
+
+### func (*PWM) Channel
+
+```go
+func (pwm *PWM) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin.
+
+
+### func (*PWM) Configure
+
+```go
+func (pwm *PWM) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this PWM.
+On the nRF52 series, the maximum period is around 0.26s.
+
+
+### func (*PWM) Set
+
+```go
+func (pwm *PWM) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle. For example, to set it to a 25% duty cycle, use:
+
+	ch.Set(ch.Top() / 4)
+
+ch.Set(0) will set the output to low and ch.Set(ch.Top()) will set the output
+to high, assuming the output isn't inverted.
+
+
+### func (*PWM) SetInverting
+
+```go
+func (pwm *PWM) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*PWM) SetPeriod
+
+```go
+func (pwm *PWM) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this PWM peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the PWM peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*PWM) Top
+
+```go
+func (pwm *PWM) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to
+pwm.Set (see pwm.Set for more information).
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when the pin is configured as an
+input or as an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*nrf.SPIM_Type
+	buf	*[1]byte	// 1-byte buffer for the Transfer method
+}
+```
+
+SPI on the NRF.
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to set up the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous
+write/read interface, there must always be the same number of bytes written
+as bytes read. Therefore, if the number of bytes don't match it will be
+padded until they fit: if len(w) > len(r) the extra bytes received will be
+dropped and if len(w) < len(r) extra 0 bytes will be sent.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer *RingBuffer
+}
+```
+
+UART on the NRF.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig)
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/xiao-rp2040.md b/content/docs/reference/microcontrollers/machine/xiao-rp2040.md
new file mode 100644
index 00000000..6eae404b
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/xiao-rp2040.md
@@ -0,0 +1,1689 @@
+
+---
+title: xiao-rp2040
+---
+
+
+## Constants
+
+```go
+const (
+	D0	Pin	= GPIO26
+	D1	Pin	= GPIO27
+	D2	Pin	= GPIO28
+	D3	Pin	= GPIO29
+	D4	Pin	= GPIO6
+	D5	Pin	= GPIO7
+	D6	Pin	= GPIO0
+	D7	Pin	= GPIO1
+	D8	Pin	= GPIO2
+	D9	Pin	= GPIO4
+	D10	Pin	= GPIO3
+)
+```
+
+Digital Pins
+
+
+```go
+const (
+	A0	Pin	= D0
+	A1	Pin	= D1
+	A2	Pin	= D2
+	A3	Pin	= D3
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	NEOPIXEL	= GPIO12
+	WS2812		= GPIO12
+	NEO_PWR		= GPIO11
+	NEOPIXEL_POWER	= GPIO11
+
+	LED		= GPIO17
+	LED_RED		= GPIO17
+	LED_GREEN	= GPIO16
+	LED_BLUE	= GPIO25
+)
+```
+
+Onboard LEDs
+
+
+```go
+const (
+	I2C0_SDA_PIN	Pin	= D2
+	I2C0_SCL_PIN	Pin	= D3
+
+	I2C1_SDA_PIN	Pin	= D4
+	I2C1_SCL_PIN	Pin	= D5
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	Pin	= D8
+	SPI0_SDO_PIN	Pin	= D10
+	SPI0_SDI_PIN	Pin	= D9
+
+	SPI1_SCK_PIN	Pin	= NoPin
+	SPI1_SDO_PIN	Pin	= NoPin
+	SPI1_SDI_PIN	Pin	= NoPin
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	UART0_TX_PIN	= GPIO0
+	UART0_RX_PIN	= GPIO1
+	UART_TX_PIN	= UART0_TX_PIN
+	UART_RX_PIN	= UART0_RX_PIN
+)
+```
+
+UART pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	LS_SE0	= 0b00
+	LS_J	= 0b01
+	LS_K	= 0b10
+	LS_SE1	= 0b11
+)
+```
+
+
+
+```go
+const (
+	cpuFreq			= 200 * MHz
+	_NUMBANK0_GPIOS		= 30
+	_NUMBANK0_IRQS		= 4
+	_NUMIRQ			= 32
+	rp2350ExtraReg		= 0
+	RESETS_RESET_Msk	= 0x01ffffff
+	initUnreset		= rp.RESETS_RESET_ADC |
+		rp.RESETS_RESET_RTC |
+		rp.RESETS_RESET_SPI0 |
+		rp.RESETS_RESET_SPI1 |
+		rp.RESETS_RESET_UART0 |
+		rp.RESETS_RESET_UART1 |
+		rp.RESETS_RESET_USBCTRL
+	initDontReset	= rp.RESETS_RESET_IO_QSPI |
+		rp.RESETS_RESET_PADS_QSPI |
+		rp.RESETS_RESET_PLL_USB |
+		rp.RESETS_RESET_USBCTRL |
+		rp.RESETS_RESET_SYSCFG |
+		rp.RESETS_RESET_PLL_SYS
+	padEnableMask	= rp.PADS_BANK0_GPIO0_IE_Msk |
+		rp.PADS_BANK0_GPIO0_OD_Msk
+)
+```
+
+
+
+```go
+const (
+	PinOutput	PinMode	= iota
+	PinInput
+	PinInputPulldown
+	PinInputPullup
+	PinAnalog
+	PinUART
+	PinPWM
+	PinI2C
+	PinSPI
+	PinPIO0
+	PinPIO1
+)
+```
+
+
+
+```go
+const (
+	ADC0	Pin	= GPIO26
+	ADC1	Pin	= GPIO27
+	ADC2	Pin	= GPIO28
+	ADC3	Pin	= GPIO29
+
+	thermADC	= 30
+)
+```
+
+Analog pins on RP2040.
+
+
+```go
+const (
+	// Edge falling
+	PinFalling	PinChange	= 4 << iota
+	// Edge rising
+	PinRising
+
+	PinToggle	= PinFalling | PinRising
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// GPIO pins
+	GPIO0	Pin	= 0	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO1	Pin	= 1	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO2	Pin	= 2	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO3	Pin	= 3	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO4	Pin	= 4	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO5	Pin	= 5	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO6	Pin	= 6	// peripherals: PWM3 channel A, I2C1 SDA
+	GPIO7	Pin	= 7	// peripherals: PWM3 channel B, I2C1 SCL
+	GPIO8	Pin	= 8	// peripherals: PWM4 channel A, I2C0 SDA
+	GPIO9	Pin	= 9	// peripherals: PWM4 channel B, I2C0 SCL
+	GPIO10	Pin	= 10	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO11	Pin	= 11	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO12	Pin	= 12	// peripherals: PWM6 channel A, I2C0 SDA
+	GPIO13	Pin	= 13	// peripherals: PWM6 channel B, I2C0 SCL
+	GPIO14	Pin	= 14	// peripherals: PWM7 channel A, I2C1 SDA
+	GPIO15	Pin	= 15	// peripherals: PWM7 channel B, I2C1 SCL
+	GPIO16	Pin	= 16	// peripherals: PWM0 channel A, I2C0 SDA
+	GPIO17	Pin	= 17	// peripherals: PWM0 channel B, I2C0 SCL
+	GPIO18	Pin	= 18	// peripherals: PWM1 channel A, I2C1 SDA
+	GPIO19	Pin	= 19	// peripherals: PWM1 channel B, I2C1 SCL
+	GPIO20	Pin	= 20	// peripherals: PWM2 channel A, I2C0 SDA
+	GPIO21	Pin	= 21	// peripherals: PWM2 channel B, I2C0 SCL
+	GPIO22	Pin	= 22	// peripherals: PWM3 channel A
+	GPIO23	Pin	= 23	// peripherals: PWM3 channel B
+	GPIO24	Pin	= 24	// peripherals: PWM4 channel A
+	GPIO25	Pin	= 25	// peripherals: PWM4 channel B
+	GPIO26	Pin	= 26	// peripherals: PWM5 channel A, I2C1 SDA
+	GPIO27	Pin	= 27	// peripherals: PWM5 channel B, I2C1 SCL
+	GPIO28	Pin	= 28	// peripherals: PWM6 channel A
+	GPIO29	Pin	= 29	// peripherals: PWM6 channel B
+)
+```
+
+
+
+```go
+const NumberOfUSBEndpoints = 8
+```
+
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (approx 8.3s).
+	//
+	// Nominal 1us per watchdog tick, 24-bit counter,
+	// but due to errata two ticks consumed per 1us.
+	// See: Errata RP2040-E1
+	WatchdogMaxTimeout = (rp.WATCHDOG_LOAD_LOAD_Msk / 1000) / 2
+)
+```
+
+
+
+```go
+const XOSC_STARTUP_DELAY_MULTIPLIER = 64
+```
+
+On some boards, the XOSC can take longer than usual to stabilize. On such
+boards, this is needed to avoid a hard fault on boot/reset. Refer to
+PICO_XOSC_STARTUP_DELAY_MULTIPLIER in the Pico SDK for additional details.
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var DefaultUART = UART0
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var (
+	UART0	= &_UART0
+	_UART0	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART0,
+	}
+
+	UART1	= &_UART1
+	_UART1	= UART{
+		Buffer:	NewRingBuffer(),
+		Bus:	rp.UART1,
+	}
+)
+```
+
+UART on the RP2040
+
+
+```go
+var RTC = (*rtcType)(unsafe.Pointer(rp.RTC))
+```
+
+
+
+```go
+var (
+	ErrRtcDelayTooSmall	= errors.New("RTC interrupt deplay is too small, shall be at least 1 second")
+	ErrRtcDelayTooLarge	= errors.New("RTC interrupt deplay is too large, shall be no more than 1 day")
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var (
+	I2C0	= &_I2C0
+	_I2C0	= I2C{
+		Bus: rp.I2C0,
+	}
+	I2C1	= &_I2C1
+	_I2C1	= I2C{
+		Bus: rp.I2C1,
+	}
+)
+```
+
+I2C on the RP2040/RP2350
+
+
+```go
+var (
+	ErrBadPeriod = errors.New("period outside valid range 8ns..268ms")
+)
+```
+
+
+
+```go
+var (
+	PWM0	= getPWMGroup(0)
+	PWM1	= getPWMGroup(1)
+	PWM2	= getPWMGroup(2)
+	PWM3	= getPWMGroup(3)
+	PWM4	= getPWMGroup(4)
+	PWM5	= getPWMGroup(5)
+	PWM6	= getPWMGroup(6)
+	PWM7	= getPWMGroup(7)
+)
+```
+
+Hardware Pulse Width Modulation (PWM) API
+PWM peripherals available on RP2040. Each peripheral has 2 pins available for
+a total of 16 available PWM outputs. Some pins may not be available on some boards.
+
+The RP2040 PWM block has 8 identical slices. Each slice can drive two PWM output signals, or
+measure the frequency or duty cycle of an input signal. This gives a total of up to 16 controllable
+PWM outputs. All 30 GPIOs can be driven by the PWM block
+
+The PWM hardware functions by continuously comparing the input value to a free-running counter. This produces a
+toggling output where the amount of time spent at the high output level is proportional to the input value. The fraction of
+time spent at the high signal level is known as the duty cycle of the signal.
+
+The default behaviour of a PWM slice is to count upward until the wrap value (\ref pwm_config_set_wrap) is reached, and then
+immediately wrap to 0. PWM slices also offer a phase-correct mode, where the counter starts to count downward after
+reaching TOP, until it reaches 0 again.
+
+
+```go
+var (
+	SPI0	= &SPI{
+		Bus: rp.SPI0,
+	}
+	SPI1	= &SPI{
+		Bus: rp.SPI1,
+	}
+)
+```
+
+SPI on the RP2040
+
+
+```go
+var (
+	ErrLSBNotSupported	= errors.New("SPI LSB unsupported on PL022")
+	ErrSPITimeout		= errors.New("SPI timeout")
+	ErrSPIBaud		= errors.New("SPI baud too low or above 66.5Mhz")
+	errSPIInvalidSDI	= errors.New("invalid SPI SDI pin")
+	errSPIInvalidSDO	= errors.New("invalid SPI SDO pin")
+	errSPIInvalidSCK	= errors.New("invalid SPI SCK pin")
+)
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the RP2040.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ChipVersion
+
+```go
+func ChipVersion() uint8
+```
+
+ChipVersion returns the version of the chip. 1 is returned for B0 and B1
+chip.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func CurrentCore
+
+```go
+func CurrentCore() int
+```
+
+CurrentCore returns the core number the call was made from.
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) is common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func GetRNG
+
+```go
+func GetRNG() (uint32, error)
+```
+
+GetRNG returns 32 bits of semi-random data based on ring oscillator.
+
+Unlike some other implementations of GetRNG, these random numbers are not
+cryptographically secure and must not be used for cryptographic operations
+(nonces, etc).
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC resets the ADC peripheral.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func NumCores
+
+```go
+func NumCores() int
+```
+
+NumCores returns number of cores available on the device.
+
+
+### func PWMPeripheral
+
+```go
+func PWMPeripheral(pin Pin) (sliceNum uint8, err error)
+```
+
+Peripheral returns the RP2040 PWM peripheral which ranges from 0 to 7. Each
+PWM peripheral has 2 channels, A and B which correspond to 0 and 1 in the program.
+This number corresponds to the package's PWM0 throughout PWM7 handles
+
+
+### func ReadTemperature
+
+```go
+func ReadTemperature() (millicelsius int32)
+```
+
+ReadTemperature does a one-shot sample of the internal temperature sensor and returns a milli-celsius reading.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig) error
+```
+
+Configure sets the ADC pin to analog input mode.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns a one-shot ADC sample reading.
+
+
+### func (ADC) GetADCChannel
+
+```go
+func (a ADC) GetADCChannel() (c ADCChannel, err error)
+```
+
+GetADCChannel returns the channel associated with the ADC pin.
+
+
+
+
+## type ADCChannel
+
+```go
+type ADCChannel uint8
+```
+
+ADCChannel is the ADC peripheral mux channel. 0-4.
+
+
+
+### func (ADCChannel) Configure
+
+```go
+func (c ADCChannel) Configure(config ADCConfig) error
+```
+
+Configure sets the channel's associated pin to analog input mode.
+The powered on temperature sensor increases ADC_AVDD current by approximately 40 μA.
+
+
+### func (ADCChannel) Pin
+
+```go
+func (c ADCChannel) Pin() (p Pin, err error)
+```
+
+The Pin method returns the GPIO Pin associated with the ADC mux channel, if it has one.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus		*rp.I2C0_Type
+	mode		I2CMode
+	txInProgress	bool
+}
+```
+
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure initializes i2c peripheral and configures I2C config's pins passed.
+Here's a list of valid SDA and SCL GPIO pins on bus I2C0 of the rp2040:
+
+	SDA: 0, 4, 8, 12, 16, 20
+	SCL: 1, 5, 9, 13, 17, 21
+
+Same as above for I2C1 bus:
+
+	SDA: 2, 6, 10, 14, 18, 26
+	SCL: 3, 7, 11, 15, 19, 27
+
+
+### func (*I2C) Listen
+
+```go
+func (i2c *I2C) Listen(addr uint16) error
+```
+
+Listen starts listening for I2C requests sent to specified address
+
+addr is the address to listen to
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) Reply
+
+```go
+func (i2c *I2C) Reply(buf []byte) error
+```
+
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the I2C frequency. It has the side effect of also
+enabling the I2C hardware if disabled beforehand.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx performs a write and then a read transfer placing the result in
+in r.
+
+Passing a nil value for w or r skips the transfer corresponding to write
+or read, respectively.
+
+	i2c.Tx(addr, nil, r)
+
+Performs only a read transfer.
+
+	i2c.Tx(addr, w, nil)
+
+Performs only a write transfer.
+
+
+### func (*I2C) WaitForEvent
+
+```go
+func (i2c *I2C) WaitForEvent(buf []byte) (evt I2CTargetEvent, count int, err error)
+```
+
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	// SDA/SCL Serial Data and clock pins. Refer to datasheet to see
+	// which pins match the desired bus.
+	SDA, SCL	Pin
+	Mode		I2CMode
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure configures the gpio pin as per mode.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get reads the pin value.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(value bool)
+```
+
+Set drives the pin high if value is true else drives it low.
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+PinChange represents one or more trigger events that can happen on a given GPIO pin
+on the RP2040. ORed PinChanges are valid input to most IRQ functions.
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus *rp.SPI0_Type
+}
+```
+
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup/initialize the SPI interface.
+Default baudrate of 4MHz is used if Frequency == 0. Default
+word length (data bits) is 8.
+Below is a list of GPIO pins corresponding to SPI0 bus on the rp2040:
+
+	SI : 0, 4, 17  a.k.a RX and MISO (if rp2040 is master)
+	SO : 3, 7, 19  a.k.a TX and MOSI (if rp2040 is master)
+	SCK: 2, 6, 18
+
+SPI1 bus GPIO pins:
+
+	SI : 8, 12
+	SO : 11, 15
+	SCK: 10, 14
+
+No pin configuration is needed of SCK, SDO and SDI needed after calling Configure.
+
+
+### func (*SPI) GetBaudRate
+
+```go
+func (spi *SPI) GetBaudRate() uint32
+```
+
+
+
+### func (*SPI) PrintRegs
+
+```go
+func (spi *SPI) PrintRegs()
+```
+
+PrintRegs prints SPI's peripheral common registries current values
+
+
+### func (*SPI) SetBaudRate
+
+```go
+func (spi *SPI) SetBaudRate(br uint32) error
+```
+
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Write a single byte and read a single byte from TX/RX FIFO.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) (err error)
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+Remark: This implementation (RP2040) allows reading into buffer with a custom repeated
+value on tx.
+
+	spi.Tx([]byte{0xff}, rx) // may cause unwanted heap allocations.
+
+This form sends 0xff and puts the result into rx buffer. Useful for reading from SD cards
+which require 0xff input on SI.
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	// LSB not supported on rp2040.
+	LSBFirst	bool
+	// Mode's two most LSB are CPOL and CPHA. i.e. Mode==2 (0b10) is CPOL=1, CPHA=0
+	Mode	uint8
+	// Serial clock pin
+	SCK	Pin
+	// TX or Serial Data Out (MOSI if rp2040 is master)
+	SDO	Pin
+	// RX or Serial Data In (MISO if rp2040 is master)
+	SDI	Pin
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*rp.UART0_Type
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the RP2040.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the baudrate to be used for the UART.
+
+
+### func (*UART) SetFormat
+
+```go
+func (uart *UART) SetFormat(databits, stopbits uint8, parity UARTParity) error
+```
+
+SetFormat for number of data bits, stop bits, and parity for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) ClearStallEPIn
+
+```go
+func (dev *USBDevice) ClearStallEPIn(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB IN endpoint.
+
+
+### func (*USBDevice) ClearStallEPOut
+
+```go
+func (dev *USBDevice) ClearStallEPOut(ep uint32)
+```
+
+Clear the ENDPOINT_HALT/stall on a USB OUT endpoint.
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+### func (*USBDevice) SetStallEPIn
+
+```go
+func (dev *USBDevice) SetStallEPIn(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB IN endpoint.
+
+
+### func (*USBDevice) SetStallEPOut
+
+```go
+func (dev *USBDevice) SetStallEPOut(ep uint32)
+```
+
+Set ENDPOINT_HALT/stall status on a USB OUT endpoint.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/machine/xiao.md b/content/docs/reference/microcontrollers/machine/xiao.md
new file mode 100644
index 00000000..bb01c2f0
--- /dev/null
+++ b/content/docs/reference/microcontrollers/machine/xiao.md
@@ -0,0 +1,1753 @@
+
+---
+title: xiao
+---
+
+
+## Constants
+
+```go
+const (
+	PA00	Pin	= 0	// peripherals: TCC2 channel 0, sercomI2CM1 SDA
+	PA01	Pin	= 1	// peripherals: TCC2 channel 1, sercomI2CM1 SCL
+	PA02	Pin	= 2
+	PA03	Pin	= 3
+	PA04	Pin	= 4	// peripherals: TCC0 channel 0
+	PA05	Pin	= 5	// peripherals: TCC0 channel 1
+	PA06	Pin	= 6	// peripherals: TCC1 channel 0
+	PA07	Pin	= 7	// peripherals: TCC1 channel 1
+	PA08	Pin	= 8	// peripherals: TCC0 channel 0, TCC1 channel 2, sercomI2CM0 SDA, sercomI2CM2 SDA
+	PA09	Pin	= 9	// peripherals: TCC0 channel 1, TCC1 channel 3, sercomI2CM0 SCL, sercomI2CM2 SCL
+	PA10	Pin	= 10	// peripherals: TCC1 channel 0, TCC0 channel 2
+	PA11	Pin	= 11	// peripherals: TCC1 channel 1, TCC0 channel 3
+	PA12	Pin	= 12	// peripherals: TCC2 channel 0, TCC0 channel 2, sercomI2CM2 SDA, sercomI2CM4 SDA
+	PA13	Pin	= 13	// peripherals: TCC2 channel 1, TCC0 channel 3, sercomI2CM2 SCL, sercomI2CM4 SCL
+	PA14	Pin	= 14	// peripherals: TCC0 channel 0
+	PA15	Pin	= 15	// peripherals: TCC0 channel 1
+	PA16	Pin	= 16	// peripherals: TCC2 channel 0, TCC0 channel 2, sercomI2CM1 SDA, sercomI2CM3 SDA
+	PA17	Pin	= 17	// peripherals: TCC2 channel 1, TCC0 channel 3, sercomI2CM1 SCL, sercomI2CM3 SCL
+	PA18	Pin	= 18	// peripherals: TCC0 channel 2
+	PA19	Pin	= 19	// peripherals: TCC0 channel 3
+	PA20	Pin	= 20	// peripherals: TCC0 channel 2
+	PA21	Pin	= 21	// peripherals: TCC0 channel 3
+	PA22	Pin	= 22	// peripherals: TCC0 channel 0, sercomI2CM3 SDA, sercomI2CM5 SDA
+	PA23	Pin	= 23	// peripherals: TCC0 channel 1, sercomI2CM3 SCL, sercomI2CM5 SCL
+	PA24	Pin	= 24	// peripherals: TCC1 channel 2
+	PA25	Pin	= 25	// peripherals: TCC1 channel 3
+	PA26	Pin	= 26
+	PA27	Pin	= 27
+	PA28	Pin	= 28
+	PA29	Pin	= 29
+	PA30	Pin	= 30	// peripherals: TCC1 channel 0
+	PA31	Pin	= 31	// peripherals: TCC1 channel 1
+	PB00	Pin	= 32
+	PB01	Pin	= 33
+	PB02	Pin	= 34	// peripherals: sercomI2CM5 SDA
+	PB03	Pin	= 35	// peripherals: sercomI2CM5 SCL
+	PB04	Pin	= 36
+	PB05	Pin	= 37
+	PB06	Pin	= 38
+	PB07	Pin	= 39
+	PB08	Pin	= 40	// peripherals: sercomI2CM4 SDA
+	PB09	Pin	= 41	// peripherals: sercomI2CM4 SCL
+	PB10	Pin	= 42	// peripherals: TCC0 channel 0
+	PB11	Pin	= 43	// peripherals: TCC0 channel 1
+	PB12	Pin	= 44	// peripherals: TCC0 channel 2, sercomI2CM4 SDA
+	PB13	Pin	= 45	// peripherals: TCC0 channel 3, sercomI2CM4 SCL
+	PB14	Pin	= 46
+	PB15	Pin	= 47
+	PB16	Pin	= 48	// peripherals: TCC0 channel 0, sercomI2CM5 SDA
+	PB17	Pin	= 49	// peripherals: TCC0 channel 1, sercomI2CM5 SCL
+	PB18	Pin	= 50
+	PB19	Pin	= 51
+	PB20	Pin	= 52
+	PB21	Pin	= 53
+	PB22	Pin	= 54
+	PB23	Pin	= 55
+	PB24	Pin	= 56
+	PB25	Pin	= 57
+	PB26	Pin	= 58
+	PB27	Pin	= 59
+	PB28	Pin	= 60
+	PB29	Pin	= 61
+	PB30	Pin	= 62	// peripherals: TCC0 channel 0, TCC1 channel 2, sercomI2CM5 SDA
+	PB31	Pin	= 63	// peripherals: TCC0 channel 1, TCC1 channel 3, sercomI2CM5 SCL
+)
+```
+
+Hardware pins
+
+
+```go
+const (
+	D0	= PA02	// can be used for PWM or DAC
+	D1	= PA04	// PWM available
+	D2	= PA10	// PWM available
+	D3	= PA11	// PWM available
+	D4	= PA08	// can be used for PWM or I2C SDA
+	D5	= PA09	// can be used for PWM or I2C SCL
+	D6	= PB08	// can be used for PWM or UART1 TX
+	D7	= PB09	// can be used for PWM or UART1 RX
+	D8	= PA07	// can be used for PWM or SPI SCK
+	D9	= PA05	// can be used for PWM or SPI SDI
+	D10	= PA06	// can be used for PWM or SPI SDO
+)
+```
+
+GPIO Pins
+
+
+```go
+const (
+	A0	= PA02	// ADC/AIN[0]
+	A1	= PA04	// ADC/AIN[4]
+	A2	= PA10	// ADC/AIN[18]
+	A3	= PA11	// ADC/AIN[19]
+	A4	= PA08	// ADC/AIN[16]
+	A5	= PA09	// ADC/AIN[17]
+	A6	= PB08	// ADC/AIN[2]
+	A7	= PB09	// ADC/AIN[3]
+	A8	= PA07	// ADC/AIN[7]
+	A9	= PA05	// ADC/AIN[6]
+	A10	= PA06	// ADC/AIN[5]
+)
+```
+
+Analog pins
+
+
+```go
+const (
+	LED	= PA17
+	LED_RXL	= PA18
+	LED_TXL	= PA19
+	LED2	= LED_RXL
+	LED3	= LED_TXL
+)
+```
+
+
+
+```go
+const (
+	USBCDC_DM_PIN	= PA24
+	USBCDC_DP_PIN	= PA25
+)
+```
+
+USBCDC pins
+
+
+```go
+const (
+	UART_TX_PIN	= D6
+	UART_RX_PIN	= D7
+)
+```
+
+UART1 pins
+
+
+```go
+const (
+	SDA_PIN	= PA08	// SDA: SERCOM2/PAD[0]
+	SCL_PIN	= PA09	// SCL: SERCOM2/PAD[1]
+)
+```
+
+I2C pins
+
+
+```go
+const (
+	SPI0_SCK_PIN	= PA07	// SCK: SERCOM0/PAD[3]
+	SPI0_SDO_PIN	= PA06	// SDO: SERCOM0/PAD[2]
+	SPI0_SDI_PIN	= PA05	// SDI: SERCOM0/PAD[1]
+)
+```
+
+SPI pins
+
+
+```go
+const (
+	I2S_SCK_PIN	= PA10
+	I2S_SDO_PIN	= PA08
+	I2S_SDI_PIN	= NoPin	// TODO: figure out what this is on Xiao
+	I2S_WS_PIN	= NoPin	// TODO: figure out what this is on Xiao
+)
+```
+
+I2S pins
+
+
+```go
+const (
+	TWI_FREQ_100KHZ	= 100000
+	TWI_FREQ_400KHZ	= 400000
+)
+```
+
+TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
+
+Deprecated: use 100 * machine.KHz or 400 * machine.KHz instead.
+
+
+```go
+const (
+	// I2CReceive indicates target has received a message from the controller.
+	I2CReceive	I2CTargetEvent	= iota
+
+	// I2CRequest indicates the controller is expecting a message from the target.
+	I2CRequest
+
+	// I2CFinish indicates the controller has ended the transaction.
+	//
+	// I2C controllers can chain multiple receive/request messages without
+	// relinquishing the bus by doing 'restarts'.  I2CFinish indicates the
+	// bus has been relinquished by an I2C 'stop'.
+	I2CFinish
+)
+```
+
+
+
+```go
+const (
+	// I2CModeController represents an I2C peripheral in controller mode.
+	I2CModeController	I2CMode	= iota
+
+	// I2CModeTarget represents an I2C peripheral in target mode.
+	I2CModeTarget
+)
+```
+
+
+
+```go
+const (
+	I2SModeSource	I2SMode	= iota
+	I2SModeReceiver
+	I2SModePDM
+	I2SModeSourceReceiver
+)
+```
+
+
+
+```go
+const (
+	I2StandardPhilips	I2SStandard	= iota
+	I2SStandardMSB
+	I2SStandardLSB
+)
+```
+
+
+
+```go
+const (
+	I2SClockSourceInternal	I2SClockSource	= iota
+	I2SClockSourceExternal
+)
+```
+
+
+
+```go
+const (
+	I2SDataFormatDefault	I2SDataFormat	= 0
+	I2SDataFormat8bit			= 8
+	I2SDataFormat16bit			= 16
+	I2SDataFormat24bit			= 24
+	I2SDataFormat32bit			= 32
+)
+```
+
+
+
+```go
+const Device = deviceName
+```
+
+Device is the running program's chip name, such as "ATSAMD51J19A" or
+"nrf52840". It is not the same as the CPU name.
+
+The constant is some hardcoded default value if the program does not target a
+particular chip but instead runs in WebAssembly for example.
+
+
+```go
+const (
+	KHz	= 1000
+	MHz	= 1000_000
+	GHz	= 1000_000_000
+)
+```
+
+Generic constants.
+
+
+```go
+const NoPin = Pin(0xff)
+```
+
+NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
+of the pins in a peripheral unconfigured (if supported by the hardware).
+
+
+```go
+const (
+	PinAnalog	PinMode	= 1
+	PinSERCOM	PinMode	= 2
+	PinSERCOMAlt	PinMode	= 3
+	PinTimer	PinMode	= 4
+	PinTimerAlt	PinMode	= 5
+	PinCom		PinMode	= 6
+	//PinAC_CLK        PinMode = 7
+	PinDigital		PinMode	= 8
+	PinInput		PinMode	= 9
+	PinInputPullup		PinMode	= 10
+	PinOutput		PinMode	= 11
+	PinTCC			PinMode	= PinTimer
+	PinTCCAlt		PinMode	= PinTimerAlt
+	PinInputPulldown	PinMode	= 12
+)
+```
+
+
+
+```go
+const (
+	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
+	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
+	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
+)
+```
+
+Pin change interrupt constants for SetInterrupt.
+
+
+```go
+const (
+	// WatchdogMaxTimeout in milliseconds (16s)
+	WatchdogMaxTimeout = (16384 * 1000) / 1024
+)
+```
+
+
+
+```go
+const (
+	// these are SAMD21 specific.
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Pos	= 0
+	usb_DEVICE_PCKSIZE_BYTE_COUNT_Mask	= 0x3FFF
+
+	usb_DEVICE_PCKSIZE_SIZE_Pos	= 28
+	usb_DEVICE_PCKSIZE_SIZE_Mask	= 0x7
+
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Pos	= 14
+	usb_DEVICE_PCKSIZE_MULTI_PACKET_SIZE_Mask	= 0x3FFF
+
+	NumberOfUSBEndpoints	= 8
+)
+```
+
+
+
+```go
+const (
+	Mode0	= 0
+	Mode1	= 1
+	Mode2	= 2
+	Mode3	= 3
+)
+```
+
+SPI phase and polarity configs CPOL and CPHA
+
+
+```go
+const (
+	// ParityNone means to not use any parity checking. This is
+	// the most common setting.
+	ParityNone	UARTParity	= iota
+
+	// ParityEven means to expect that the total number of 1 bits sent
+	// should be an even number.
+	ParityEven
+
+	// ParityOdd means to expect that the total number of 1 bits sent
+	// should be an odd number.
+	ParityOdd
+)
+```
+
+
+
+
+
+
+## Variables
+
+```go
+var UART1 = &sercomUSART4
+```
+
+UART1 on the Xiao
+
+
+```go
+var (
+	I2C0 = sercomI2CM2
+)
+```
+
+I2C on the Xiao
+
+
+```go
+var SPI0 = sercomSPIM0
+```
+
+SPI on the Xiao
+
+
+```go
+var (
+	DefaultUART = UART1
+)
+```
+
+
+
+```go
+var (
+	ErrInvalidSampleFrequency = errors.New("i2s: invalid sample frequency")
+)
+```
+
+
+
+```go
+var (
+	ErrTimeoutRNG		= errors.New("machine: RNG Timeout")
+	ErrClockRNG		= errors.New("machine: RNG Clock Error")
+	ErrSeedRNG		= errors.New("machine: RNG Seed Error")
+	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
+	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
+	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
+	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
+	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
+)
+```
+
+
+
+```go
+var I2S0 = I2S{Bus: sam.I2S}
+```
+
+
+
+```go
+var (
+	TCC0	= (*TCC)(sam.TCC0)
+	TCC1	= (*TCC)(sam.TCC1)
+	TCC2	= (*TCC)(sam.TCC2)
+)
+```
+
+The SAM D21 has three TCC peripherals, which have PWM as one feature.
+
+
+```go
+var (
+	DAC0 = DAC{}
+)
+```
+
+
+
+```go
+var Flash flashBlockDevice
+```
+
+
+
+```go
+var Watchdog = &watchdogImpl{}
+```
+
+Watchdog provides access to the hardware watchdog available
+in the SAMD21.
+
+
+```go
+var (
+	ErrPWMPeriodTooLong = errors.New("pwm: period too long")
+)
+```
+
+
+
+```go
+var Serial Serialer
+```
+
+Serial is implemented via USB (USB-CDC).
+
+
+```go
+var (
+	ErrTxInvalidSliceSize		= errors.New("SPI write and read slices must be same size")
+	errSPIInvalidMachineConfig	= errors.New("SPI port was not configured properly by the machine")
+)
+```
+
+
+
+```go
+var (
+	USBDev	= &USBDevice{}
+	USBCDC	Serialer
+)
+```
+
+
+
+```go
+var (
+	ErrUSBReadTimeout	= errors.New("USB read timeout")
+	ErrUSBBytesRead		= errors.New("USB invalid number of bytes read")
+	ErrUSBBytesWritten	= errors.New("USB invalid number of bytes written")
+)
+```
+
+
+
+
+
+
+### func AckUsbOutTransfer
+
+```go
+func AckUsbOutTransfer(ep uint32)
+```
+
+AckUsbOutTransfer is called to acknowledge the completion of a USB OUT transfer.
+
+
+### func CPUFrequency
+
+```go
+func CPUFrequency() uint32
+```
+
+Return the current CPU frequency in hertz.
+
+
+### func CPUReset
+
+```go
+func CPUReset()
+```
+
+CPUReset performs a hard system reset.
+
+
+### func ConfigureUSBEndpoint
+
+```go
+func ConfigureUSBEndpoint(desc descriptor.Descriptor, epSettings []usb.EndpointConfig, setup []usb.SetupConfig)
+```
+
+
+
+### func DeviceID
+
+```go
+func DeviceID() []byte
+```
+
+DeviceID returns an identifier that is unique within
+a particular chipset.
+
+The identity is one burnt into the MCU itself, or the
+flash chip at time of manufacture.
+
+It's possible that two different vendors may allocate
+the same DeviceID, so callers should take this into
+account if needing to generate a globally unique id.
+
+The length of the hardware ID is vendor-specific, but
+8 bytes (64 bits) and 16 bytes (128 bits) are common.
+
+
+### func EnableCDC
+
+```go
+func EnableCDC(txHandler func(), rxHandler func([]byte), setupHandler func(usb.Setup) bool)
+```
+
+
+
+### func EnterBootloader
+
+```go
+func EnterBootloader()
+```
+
+EnterBootloader should perform a system reset in preparation
+to switch to the bootloader to flash new firmware.
+
+
+### func FlashDataEnd
+
+```go
+func FlashDataEnd() uintptr
+```
+
+Return the end of the writable flash area. Usually this is the address one
+past the end of the on-chip flash.
+
+
+### func FlashDataStart
+
+```go
+func FlashDataStart() uintptr
+```
+
+Return the start of the writable flash area, aligned on a page boundary. This
+is usually just after the program and static data.
+
+
+### func InitADC
+
+```go
+func InitADC()
+```
+
+InitADC initializes the ADC.
+
+
+### func InitSerial
+
+```go
+func InitSerial()
+```
+
+
+
+### func NewRingBuffer
+
+```go
+func NewRingBuffer() *RingBuffer
+```
+
+NewRingBuffer returns a new ring buffer.
+
+
+### func ReceiveUSBControlPacket
+
+```go
+func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error)
+```
+
+
+
+### func SendUSBInPacket
+
+```go
+func SendUSBInPacket(ep uint32, data []byte) bool
+```
+
+SendUSBInPacket sends a packet for USB (interrupt in / bulk in).
+
+
+### func SendZlp
+
+```go
+func SendZlp()
+```
+
+
+
+
+
+## type ADC
+
+```go
+type ADC struct {
+	Pin Pin
+}
+```
+
+
+
+
+### func (ADC) Configure
+
+```go
+func (a ADC) Configure(config ADCConfig)
+```
+
+Configure configures a ADC pin to be able to be used to read data.
+
+
+### func (ADC) Get
+
+```go
+func (a ADC) Get() uint16
+```
+
+Get returns the current value of a ADC pin, in the range 0..0xffff.
+
+
+
+
+## type ADCConfig
+
+```go
+type ADCConfig struct {
+	Reference	uint32	// analog reference voltage (AREF) in millivolts
+	Resolution	uint32	// number of bits for a single conversion (e.g., 8, 10, 12)
+	Samples		uint32	// number of samples for a single conversion (e.g., 4, 8, 16, 32)
+	SampleTime	uint32	// sample time, in microseconds (µs)
+}
+```
+
+ADCConfig holds ADC configuration parameters. If left unspecified, the zero
+value of each parameter will use the peripheral's default settings.
+
+
+
+
+
+## type BlockDevice
+
+```go
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+```
+
+BlockDevice is the raw device that is meant to store flash data.
+
+
+
+
+
+## type DAC
+
+```go
+type DAC struct {
+}
+```
+
+DAC on the SAMD21.
+
+
+
+### func (DAC) Configure
+
+```go
+func (dac DAC) Configure(config DACConfig)
+```
+
+Configure the DAC.
+output pin must already be configured.
+
+
+### func (DAC) Set
+
+```go
+func (dac DAC) Set(value uint16) error
+```
+
+Set writes a single 16-bit value to the DAC.
+Since the ATSAMD21 only has a 10-bit DAC, the passed-in value will be scaled down.
+
+
+
+
+## type DACConfig
+
+```go
+type DACConfig struct {
+}
+```
+
+DACConfig placeholder for future expansion.
+
+
+
+
+
+## type I2C
+
+```go
+type I2C struct {
+	Bus	*sam.SERCOM_I2CM_Type
+	SERCOM	uint8
+}
+```
+
+I2C on the SAMD21.
+
+
+
+### func (*I2C) Configure
+
+```go
+func (i2c *I2C) Configure(config I2CConfig) error
+```
+
+Configure is intended to setup the I2C interface.
+
+
+### func (*I2C) ReadRegister
+
+```go
+func (i2c *I2C) ReadRegister(address uint8, register uint8, data []byte) error
+```
+
+ReadRegister transmits the register, restarts the connection as a read
+operation, and reads the response.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily read such registers. Also, it only works for devices
+with 7-bit addresses, which is the vast majority.
+
+
+### func (*I2C) SetBaudRate
+
+```go
+func (i2c *I2C) SetBaudRate(br uint32) error
+```
+
+SetBaudRate sets the communication speed for I2C.
+
+
+### func (*I2C) Tx
+
+```go
+func (i2c *I2C) Tx(addr uint16, w, r []byte) error
+```
+
+Tx does a single I2C transaction at the specified address.
+It clocks out the given address, writes the bytes in w, reads back len(r)
+bytes and stores them in r, and generates a stop condition on the bus.
+
+
+### func (*I2C) WriteByte
+
+```go
+func (i2c *I2C) WriteByte(data byte) error
+```
+
+WriteByte writes a single byte to the I2C bus.
+
+
+### func (*I2C) WriteRegister
+
+```go
+func (i2c *I2C) WriteRegister(address uint8, register uint8, data []byte) error
+```
+
+WriteRegister transmits first the register and then the data to the
+peripheral device.
+
+Many I2C-compatible devices are organized in terms of registers. This method
+is a shortcut to easily write to such registers. Also, it only works for
+devices with 7-bit addresses, which is the vast majority.
+
+
+
+
+## type I2CConfig
+
+```go
+type I2CConfig struct {
+	Frequency	uint32
+	SCL		Pin
+	SDA		Pin
+}
+```
+
+I2CConfig is used to store config info for I2C.
+
+
+
+
+
+## type I2CMode
+
+```go
+type I2CMode int
+```
+
+I2CMode determines if an I2C peripheral is in Controller or Target mode.
+
+
+
+
+
+## type I2CTargetEvent
+
+```go
+type I2CTargetEvent uint8
+```
+
+I2CTargetEvent reflects events on the I2C bus
+
+
+
+
+
+## type I2S
+
+```go
+type I2S struct {
+	Bus		*sam.I2S_Type
+	Frequency	uint32
+	DataFormat	I2SDataFormat
+}
+```
+
+I2S
+
+
+
+### func (*I2S) Configure
+
+```go
+func (i2s *I2S) Configure(config I2SConfig) error
+```
+
+Configure is used to configure the I2S interface. You must call this
+before you can use the I2S bus.
+
+
+### func (*I2S) Enable
+
+```go
+func (i2s *I2S) Enable(enabled bool)
+```
+
+Enabled is used to enable or disable the I2S bus.
+
+
+### func (*I2S) ReadMono
+
+```go
+func (i2s *I2S) ReadMono(p []uint16) (n int, err error)
+```
+
+Read mono data from the I2S bus into the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) ReadStereo
+
+```go
+func (i2s *I2S) ReadStereo(p []uint32) (n int, err error)
+```
+
+Read stereo data from the I2S bus into the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) SetSampleFrequency
+
+```go
+func (i2s *I2S) SetSampleFrequency(freq uint32) error
+```
+
+SetSampleFrequency is used to set the sample frequency for the I2S bus.
+
+
+### func (*I2S) WriteMono
+
+```go
+func (i2s *I2S) WriteMono(p []uint16) (n int, err error)
+```
+
+Write mono data to the I2S bus from the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+### func (*I2S) WriteStereo
+
+```go
+func (i2s *I2S) WriteStereo(p []uint32) (n int, err error)
+```
+
+Write stereo data to the I2S bus from the provided slice.
+The I2S bus must already have been configured correctly.
+
+
+
+
+## type I2SClockSource
+
+```go
+type I2SClockSource uint8
+```
+
+
+
+
+
+
+## type I2SConfig
+
+```go
+type I2SConfig struct {
+	// clock
+	SCK	Pin
+	// word select
+	WS	Pin
+	// data out
+	SDO	Pin
+	// data in
+	SDI		Pin
+	Mode		I2SMode
+	Standard	I2SStandard
+	ClockSource	I2SClockSource
+	DataFormat	I2SDataFormat
+	AudioFrequency	uint32
+	MainClockOutput	bool
+	Stereo		bool
+}
+```
+
+All fields are optional and may not be required or used on a particular platform.
+
+
+
+
+
+## type I2SDataFormat
+
+```go
+type I2SDataFormat uint8
+```
+
+
+
+
+
+
+## type I2SMode
+
+```go
+type I2SMode uint8
+```
+
+
+
+
+
+
+## type I2SStandard
+
+```go
+type I2SStandard uint8
+```
+
+
+
+
+
+
+## type NullSerial
+
+```go
+type NullSerial struct {
+}
+```
+
+NullSerial is a serial version of /dev/null (or null router): it drops
+everything that is written to it.
+
+
+
+### func (NullSerial) Buffered
+
+```go
+func (ns NullSerial) Buffered() int
+```
+
+Buffered returns how many bytes are buffered in the UART. It always returns 0
+as there are no bytes to read.
+
+
+### func (NullSerial) Configure
+
+```go
+func (ns NullSerial) Configure(config UARTConfig) error
+```
+
+Configure does nothing: the null serial has no configuration.
+
+
+### func (NullSerial) ReadByte
+
+```go
+func (ns NullSerial) ReadByte() (byte, error)
+```
+
+ReadByte always returns an error because there aren't any bytes to read.
+
+
+### func (NullSerial) Write
+
+```go
+func (ns NullSerial) Write(p []byte) (n int, err error)
+```
+
+Write is a no-op: none of the data is being written and it will not return an
+error.
+
+
+### func (NullSerial) WriteByte
+
+```go
+func (ns NullSerial) WriteByte(b byte) error
+```
+
+WriteByte is a no-op: the null serial doesn't write bytes.
+
+
+
+
+## type PDMConfig
+
+```go
+type PDMConfig struct {
+	Stereo	bool
+	DIN	Pin
+	CLK	Pin
+}
+```
+
+
+
+
+
+
+## type PWMConfig
+
+```go
+type PWMConfig struct {
+	// PWM period in nanosecond. Leaving this zero will pick a reasonable period
+	// value for use with LEDs.
+	// If you want to configure a frequency instead of a period, you can use the
+	// following formula to calculate a period from a frequency:
+	//
+	//     period = 1e9 / frequency
+	//
+	Period uint64
+}
+```
+
+PWMConfig allows setting some configuration while configuring a PWM
+peripheral. A zero PWMConfig is ready to use for simple applications such as
+dimming LEDs.
+
+
+
+
+
+## type Pin
+
+```go
+type Pin uint8
+```
+
+Pin is a single pin on a chip, which may be connected to other hardware
+devices. It can either be used directly as GPIO pin or it can be used in
+other peripherals like ADC, I2C, etc.
+
+
+
+### func (Pin) Configure
+
+```go
+func (p Pin) Configure(config PinConfig)
+```
+
+Configure this pin with the given configuration.
+
+
+### func (Pin) Get
+
+```go
+func (p Pin) Get() bool
+```
+
+Get returns the current value of a GPIO pin when configured as an input or as
+an output.
+
+
+### func (Pin) High
+
+```go
+func (p Pin) High()
+```
+
+High sets this GPIO pin to high, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to high that is not configured as an output pin.
+
+
+### func (Pin) Low
+
+```go
+func (p Pin) Low()
+```
+
+Low sets this GPIO pin to low, assuming it has been configured as an output
+pin. It is hardware dependent (and often undefined) what happens if you set a
+pin to low that is not configured as an output pin.
+
+
+### func (Pin) PortMaskClear
+
+```go
+func (p Pin) PortMaskClear() (*uint32, uint32)
+```
+
+Return the register and mask to disable a given port. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) PortMaskSet
+
+```go
+func (p Pin) PortMaskSet() (*uint32, uint32)
+```
+
+Return the register and mask to enable a given GPIO pin. This can be used to
+implement bit-banged drivers.
+
+
+### func (Pin) Set
+
+```go
+func (p Pin) Set(high bool)
+```
+
+Set the pin to high or low.
+Warning: only use this on an output pin!
+
+
+### func (Pin) SetInterrupt
+
+```go
+func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
+```
+
+SetInterrupt sets an interrupt to be executed when a particular pin changes
+state. The pin should already be configured as an input, including a pull up
+or down if no external pull is provided.
+
+This call will replace a previously set callback on this pin. You can pass a
+nil func to unset the pin change interrupt. If you do so, the change
+parameter is ignored and can be set to any value (such as 0).
+
+
+
+
+## type PinChange
+
+```go
+type PinChange uint8
+```
+
+
+
+
+
+
+## type PinConfig
+
+```go
+type PinConfig struct {
+	Mode PinMode
+}
+```
+
+
+
+
+
+
+## type PinMode
+
+```go
+type PinMode uint8
+```
+
+PinMode sets the direction and pull mode of the pin. For example, PinOutput
+sets the pin as an output and PinInputPullup sets the pin as an input with a
+pull-up.
+
+
+
+
+
+## type RingBuffer
+
+```go
+type RingBuffer struct {
+	rxbuffer	[bufferSize]volatile.Register8
+	head		volatile.Register8
+	tail		volatile.Register8
+}
+```
+
+RingBuffer is ring buffer implementation inspired by post at
+https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
+
+
+
+### func (*RingBuffer) Clear
+
+```go
+func (rb *RingBuffer) Clear()
+```
+
+Clear resets the head and tail pointer to zero.
+
+
+### func (*RingBuffer) Get
+
+```go
+func (rb *RingBuffer) Get() (byte, bool)
+```
+
+Get returns a byte from the buffer. If the buffer is empty,
+the method will return a false as the second value.
+
+
+### func (*RingBuffer) Put
+
+```go
+func (rb *RingBuffer) Put(val byte) bool
+```
+
+Put stores a byte in the buffer. If the buffer is already
+full, the method will return false.
+
+
+### func (*RingBuffer) Used
+
+```go
+func (rb *RingBuffer) Used() uint8
+```
+
+Used returns how many bytes in buffer have been used.
+
+
+
+
+## type SPI
+
+```go
+type SPI struct {
+	Bus	*sam.SERCOM_SPI_Type
+	SERCOM	uint8
+}
+```
+
+SPI
+
+
+
+### func (*SPI) Configure
+
+```go
+func (spi *SPI) Configure(config SPIConfig) error
+```
+
+Configure is intended to setup the SPI interface.
+
+
+### func (*SPI) Transfer
+
+```go
+func (spi *SPI) Transfer(w byte) (byte, error)
+```
+
+Transfer writes/reads a single byte using the SPI interface.
+
+
+### func (*SPI) Tx
+
+```go
+func (spi *SPI) Tx(w, r []byte) error
+```
+
+Tx handles read/write operation for SPI interface. Since SPI is a synchronous write/read
+interface, there must always be the same number of bytes written as bytes read.
+The Tx method knows about this, and offers a few different ways of calling it.
+
+This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
+Note that the tx and rx buffers must be the same size:
+
+	spi.Tx(tx, rx)
+
+This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
+until all the bytes in the command packet have been received:
+
+	spi.Tx(tx, nil)
+
+This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
+
+	spi.Tx(nil, rx)
+
+
+
+
+## type SPIConfig
+
+```go
+type SPIConfig struct {
+	Frequency	uint32
+	SCK		Pin
+	SDO		Pin
+	SDI		Pin
+	LSBFirst	bool
+	Mode		uint8
+}
+```
+
+SPIConfig is used to store config info for SPI.
+
+
+
+
+
+## type Serialer
+
+```go
+type Serialer interface {
+	WriteByte(c byte) error
+	Write(data []byte) (n int, err error)
+	Configure(config UARTConfig) error
+	Buffered() int
+	ReadByte() (byte, error)
+	DTR() bool
+	RTS() bool
+}
+```
+
+
+
+
+
+
+## type TCC
+
+```go
+type TCC sam.TCC_Type
+```
+
+TCC is one timer/counter peripheral, which consists of a counter and multiple
+output channels (that can be connected to actual pins). You can set the
+frequency using SetPeriod, but only for all the channels in this TCC
+peripheral at once.
+
+
+
+### func (*TCC) Channel
+
+```go
+func (tcc *TCC) Channel(pin Pin) (uint8, error)
+```
+
+Channel returns a PWM channel for the given pin. Note that one channel may be
+shared between multiple pins, and so will have the same duty cycle. If this
+is not desirable, look for a different TCC peripheral or consider using a
+different pin.
+
+
+### func (*TCC) Configure
+
+```go
+func (tcc *TCC) Configure(config PWMConfig) error
+```
+
+Configure enables and configures this TCC.
+
+
+### func (*TCC) Counter
+
+```go
+func (tcc *TCC) Counter() uint32
+```
+
+Counter returns the current counter value of the timer in this TCC
+peripheral. It may be useful for debugging.
+
+
+### func (*TCC) Set
+
+```go
+func (tcc *TCC) Set(channel uint8, value uint32)
+```
+
+Set updates the channel value. This is used to control the channel duty
+cycle, in other words the fraction of time the channel output is high (or low
+when inverted). For example, to set it to a 25% duty cycle, use:
+
+	tcc.Set(channel, tcc.Top() / 4)
+
+tcc.Set(channel, 0) will set the output to low and tcc.Set(channel,
+tcc.Top()) will set the output to high, assuming the output isn't inverted.
+
+
+### func (*TCC) SetInverting
+
+```go
+func (tcc *TCC) SetInverting(channel uint8, inverting bool)
+```
+
+SetInverting sets whether to invert the output of this channel.
+Without inverting, a 25% duty cycle would mean the output is high for 25% of
+the time and low for the rest. Inverting flips the output as if a NOT gate
+was placed at the output, meaning that the output would be 25% low and 75%
+high with a duty cycle of 25%.
+
+
+### func (*TCC) SetPeriod
+
+```go
+func (tcc *TCC) SetPeriod(period uint64) error
+```
+
+SetPeriod updates the period of this TCC peripheral.
+To set a particular frequency, use the following formula:
+
+	period = 1e9 / frequency
+
+If you use a period of 0, a period that works well for LEDs will be picked.
+
+SetPeriod will not change the prescaler, but also won't change the current
+value in any of the channels. This means that you may need to update the
+value for the particular channel.
+
+Note that you cannot pick any arbitrary period after the TCC peripheral has
+been configured. If you want to switch between frequencies, pick the lowest
+frequency (longest period) once when calling Configure and adjust the
+frequency here as needed.
+
+
+### func (*TCC) Top
+
+```go
+func (tcc *TCC) Top() uint32
+```
+
+Top returns the current counter top, for use in duty cycle calculation. It
+will only change with a call to Configure or SetPeriod, otherwise it is
+constant.
+
+The value returned here is hardware dependent. In general, it's best to treat
+it as an opaque value that can be divided by some number and passed to Set
+(see Set documentation for more information).
+
+
+
+
+## type UART
+
+```go
+type UART struct {
+	Buffer		*RingBuffer
+	Bus		*sam.SERCOM_USART_Type
+	SERCOM		uint8
+	Interrupt	interrupt.Interrupt
+}
+```
+
+UART on the SAMD21.
+
+
+
+### func (*UART) Buffered
+
+```go
+func (uart *UART) Buffered() int
+```
+
+Buffered returns the number of bytes currently stored in the RX buffer.
+
+
+### func (*UART) Configure
+
+```go
+func (uart *UART) Configure(config UARTConfig) error
+```
+
+Configure the UART.
+
+
+### func (*UART) Read
+
+```go
+func (uart *UART) Read(data []byte) (n int, err error)
+```
+
+Read from the RX buffer.
+
+
+### func (*UART) ReadByte
+
+```go
+func (uart *UART) ReadByte() (byte, error)
+```
+
+ReadByte reads a single byte from the RX buffer.
+If there is no data in the buffer, returns an error.
+
+
+### func (*UART) Receive
+
+```go
+func (uart *UART) Receive(data byte)
+```
+
+Receive handles adding data to the UART's data buffer.
+Usually called by the IRQ handler for a machine.
+
+
+### func (*UART) SetBaudRate
+
+```go
+func (uart *UART) SetBaudRate(br uint32)
+```
+
+SetBaudRate sets the communication speed for the UART.
+
+
+### func (*UART) Write
+
+```go
+func (uart *UART) Write(data []byte) (n int, err error)
+```
+
+Write data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+### func (*UART) WriteByte
+
+```go
+func (uart *UART) WriteByte(c byte) error
+```
+
+WriteByte writes a byte of data over the UART's Tx.
+This function blocks until the data is finished being sent.
+
+
+
+
+## type UARTConfig
+
+```go
+type UARTConfig struct {
+	BaudRate	uint32
+	TX		Pin
+	RX		Pin
+	RTS		Pin
+	CTS		Pin
+}
+```
+
+UARTConfig is a struct with which a UART (or similar object) can be
+configured. The baud rate is usually respected, but TX and RX may be ignored
+depending on the chip and the type of object.
+
+
+
+
+
+## type UARTParity
+
+```go
+type UARTParity uint8
+```
+
+UARTParity is the parity setting to be used for UART communication.
+
+
+
+
+
+## type USBDevice
+
+```go
+type USBDevice struct {
+	initcomplete		bool
+	InitEndpointComplete	bool
+}
+```
+
+
+
+
+### func (*USBDevice) Configure
+
+```go
+func (dev *USBDevice) Configure(config UARTConfig)
+```
+
+Configure the USB peripheral. The config is here for compatibility with the UART interface.
+
+
+
+
+## type WatchdogConfig
+
+```go
+type WatchdogConfig struct {
+	// The timeout (in milliseconds) before the watchdog fires.
+	//
+	// If the requested timeout exceeds `MaxTimeout` it will be rounded
+	// down.
+	TimeoutMillis uint32
+}
+```
+
+WatchdogConfig holds configuration for the watchdog timer.
+
+
+
+
+
diff --git a/content/docs/reference/microcontrollers/macropad-rp2040.md b/content/docs/reference/microcontrollers/macropad-rp2040.md
new file mode 100644
index 00000000..e4a26ebe
--- /dev/null
+++ b/content/docs/reference/microcontrollers/macropad-rp2040.md
@@ -0,0 +1,83 @@
+---
+title: "Adafruit MacroPad RP2040"
+weight: 3
+---
+
+The [Adafruit MacroPad RP2040](https://www.adafruit.com/product/5100) is a tiny development board based on the Raspberry Pi [RP2040](https://datasheets.raspberrypi.org/rp2040/rp2040-datasheet.pdf) microcontroller.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `SWITCH`          | `GPIO0`      | `BUTTON`, `UART0_TX_PIN`, `UART_TX_PIN` | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `KEY1`            | `GPIO1`      | `UART0_RX_PIN`, `UART_RX_PIN` | `I2C0` (SCL)         | `PWM0` (channel B)   |
+| `KEY2`            | `GPIO2`      |                   | `I2C1` (SDA)         | `PWM1` (channel A)   |
+| `KEY3`            | `GPIO3`      |                   | `I2C1` (SCL)         | `PWM1` (channel B)   |
+| `KEY4`            | `GPIO4`      |                   | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `KEY5`            | `GPIO5`      |                   | `I2C0` (SCL)         | `PWM2` (channel B)   |
+| `KEY6`            | `GPIO6`      |                   | `I2C1` (SDA)         | `PWM3` (channel A)   |
+| `KEY7`            | `GPIO7`      |                   | `I2C1` (SCL)         | `PWM3` (channel B)   |
+| `KEY8`            | `GPIO8`      |                   | `I2C0` (SDA)         | `PWM4` (channel A)   |
+| `KEY9`            | `GPIO9`      |                   | `I2C0` (SCL)         | `PWM4` (channel B)   |
+| `KEY10`           | `GPIO10`     |                   | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `KEY11`           | `GPIO11`     |                   | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `KEY12`           | `GPIO12`     |                   | `I2C0` (SDA)         | `PWM6` (channel A)   |
+| `LED`             | `GPIO13`     |                   | `I2C0` (SCL)         | `PWM6` (channel B)   |
+| `SPEAKER_ENABLE`  | `GPIO14`     |                   | `I2C1` (SDA)         | `PWM7` (channel A)   |
+| `SPEAKER`         | `GPIO16`     |                   | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `ROT_A`           | `GPIO18`     |                   | `I2C1` (SDA)         | `PWM1` (channel A)   |
+| `ROT_B`           | `GPIO17`     |                   | `I2C0` (SCL)         | `PWM0` (channel B)   |
+| `OLED_CS`         | `GPIO22`     |                   |                      | `PWM3` (channel A)   |
+| `OLED_RST`        | `GPIO23`     |                   |                      | `PWM3` (channel B)   |
+| `OLED_DC`         | `GPIO24`     |                   |                      | `PWM4` (channel A)   |
+| `NEOPIXEL`        | `GPIO19`     | `WS2812`          | `I2C1` (SCL)         | `PWM1` (channel B)   |
+| `I2C0_SDA_PIN`    | `GPIO20`     |                   | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `I2C0_SCL_PIN`    | `GPIO21`     |                   | `I2C0` (SCL)         | `PWM2` (channel B)   |
+| `SPI1_SCK_PIN`    | `GPIO26`     | `ADC0`            | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `SPI1_SDO_PIN`    | `GPIO27`     | `ADC1`            | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `SPI1_SDI_PIN`    | `GPIO28`     | `ADC2`            |                      | `PWM6` (channel A)   |
+| `ADC3`            | `GPIO29`     |                   |                      | `PWM6` (channel B)   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Adafruit MacroPad RP2040](../machine/macropad-rp2040)
+
+## Flashing
+
+### UF2
+
+The MacroPad RP2040 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=macropad-rp2040 [PATH TO YOUR PROGRAM]
+    ```
+
+- The MacroPad RP2040 board should restart and then begin running your program.
+
+### Troubleshooting
+
+Any troubleshooting tips go here.
+
+## Notes
+
+You can use the USB port to the MacroPad RP2040 as a serial port.
+
+TinyGo has support for the RP2040's on-board Programmable Input/Output (PIO) block.
+
+For more informantion, see [https://github.com/tinygo-org/pio](https://github.com/tinygo-org/pio)
diff --git a/content/docs/reference/microcontrollers/maixbit.md b/content/docs/reference/microcontrollers/maixbit.md
new file mode 100644
index 00000000..a3b33add
--- /dev/null
+++ b/content/docs/reference/microcontrollers/maixbit.md
@@ -0,0 +1,83 @@
+---
+title: "Seeed Sipeed MAix Bit"
+weight: 3
+---
+
+The [Sipeed MAix Bit](https://www.seeedstudio.com/Sipeed-MAix-BiT-for-RISC-V-AI-IoT-p-2872.html) is a low-cost development board featuring the [Kendryte K210](https://canaan.io/product/kendryteai) [RISC-V](https://riscv.org/) (RV64GC) chip.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | NO  | NO  |
+| PWM       | YES | Not yet |
+| USBDevice | ?   | ?   |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `D0`              | `P00`        |                   |
+| `D1`              | `P01`        |                   |
+| `D2`              | `P02`        |                   |
+| `D3`              | `P03`        |                   |
+| `D4`              | `P04`        | `UART_RX_PIN`     |
+| `D5`              | `P05`        | `UART_TX_PIN`     |
+| `D6`              | `P06`        |                   |
+| `D7`              | `P07`        |                   |
+| `D8`              | `P08`        |                   |
+| `D9`              | `P09`        |                   |
+| `D10`             | `P10`        |                   |
+| `D11`             | `P11`        |                   |
+| `D12`             | `P12`        | `LED2`, `LED_GREEN` |
+| `D13`             | `P13`        | `LED`, `LED1`, `LED_RED` |
+| `D14`             | `P14`        | `LED3`, `LED_BLUE` |
+| `D15`             | `P15`        |                   |
+| `D16`             | `P16`        |                   |
+| `D17`             | `P17`        |                   |
+| `D18`             | `P18`        |                   |
+| `D19`             | `P19`        |                   |
+| `D20`             | `P20`        |                   |
+| `D21`             | `P21`        |                   |
+| `D22`             | `P22`        |                   |
+| `D23`             | `P23`        |                   |
+| `D24`             | `P24`        |                   |
+| `D25`             | `P25`        |                   |
+| `D26`             | `P26`        | `SPI0_SDI_PIN`    |
+| `D27`             | `P27`        | `SPI0_SCK_PIN`    |
+| `D28`             | `P28`        | `SPI0_SDO_PIN`    |
+| `D29`             | `P29`        |                   |
+| `D30`             | `P30`        |                   |
+| `D31`             | `P31`        |                   |
+| `D32`             | `P32`        |                   |
+| `D33`             | `P33`        |                   |
+| `D34`             | `P34`        | `I2C0_SDA_PIN`    |
+| `D35`             | `P35`        | `I2C0_SCL_PIN`    |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Sipeed MAix Bit](../machine/maixbit)
+
+## Flashing
+
+### Kflash.py
+
+Programs are loaded onto the MAix Bit using the `kflash.py` command line utility program. You must install this program before you will be able to flash the MAix Bit board with your TinyGo code.
+
+The latest version of the `kflash.py` can be installed using `pip3 install kflash`.
+
+- Plug your MAix Bit into your computer's USB port.
+- Build and flash your TinyGo program using `tinygo flash -target=maixbit [PATH TO YOUR PROGRAM]`
+
+## Troubleshooting
+
+You may get the following error when flashing the MAix Bit:
+
+```shell
+error: unable to locate a serial port
+```
+To resolve this, just specify the MAix Bit's serial port when flashing using `tinygo flash -target=maixbit -port=[MAIXBIT PORT] [PATH TO YOUR PROGRAM]`.
diff --git a/content/docs/reference/microcontrollers/matrixportal-m4.md b/content/docs/reference/microcontrollers/matrixportal-m4.md
new file mode 100644
index 00000000..6f858232
--- /dev/null
+++ b/content/docs/reference/microcontrollers/matrixportal-m4.md
@@ -0,0 +1,109 @@
+---
+title: "Adafruit Matrix Portal M4"
+weight: 3
+---
+
+The [Adafruit Matrix Portal M4](https://www.adafruit.com/product/4745) is an ARM development system based on the [ATSAMD51J19 Cortex M4 processor](https://www.microchip.com/wwwproducts/en/ATSAMD51J19). The Adafruit Matrix Portal M4 is designed to plugin easily to any HUB-75 LED display. In addition it has a built-in ESP32 Wi-Fi coprocessor, along with a LIS3DH accelerometer.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `D0`              | `PA01`       | `UART1_RX_PIN`, `UART_RX_PIN` |                      |                      |
+| `D1`              | `PA00`       | `UART1_TX_PIN`, `UART_TX_PIN` |                      |                      |
+| `D2`              | `PB22`       | `BUTTON_UP`       |                      |                      |
+| `D3`              | `PB23`       | `BUTTON_DOWN`     |                      |                      |
+| `D4`              | `PA23`       | `NEOPIXEL`, `WS2812` | `I2C0` (SCL)         | `TCC1` (channel 7), `TCC0` (channel 3) |
+| `D5`              | `PB31`       | `I2C0_SDA_PIN`, `I2C_SDA_PIN`, `SDA_PIN` |                      | `TCC4` (channel 1), `TCC0` (channel 7) |
+| `D6`              | `PB30`       | `I2C0_SCL_PIN`, `I2C_SCL_PIN`, `SCL_PIN` |                      | `TCC4` (channel 0), `TCC0` (channel 6) |
+| `D7`              | `PB00`       | `HUB75_R1`        |                      |                      |
+| `D8`              | `PB01`       | `HUB75_G1`        |                      |                      |
+| `D9`              | `PB02`       | `HUB75_B1`        |                      | `TCC2` (channel 2)   |
+| `D10`             | `PB03`       | `HUB75_R2`        |                      | `TCC2` (channel 3)   |
+| `D11`             | `PB04`       | `HUB75_G2`        |                      |                      |
+| `D12`             | `PB05`       | `HUB75_B2`        |                      |                      |
+| `D13`             | `PA14`       | `LED`             |                      | `TCC2` (channel 0), `TCC1` (channel 2) |
+| `D14`             | `PB06`       | `HUB75_CLK`       |                      |                      |
+| `D15`             | `PB14`       | `HUB75_LAT`       |                      | `TCC4` (channel 0), `TCC0` (channel 2) |
+| `D16`             | `PB12`       | `HUB75_OE`        |                      | `TCC3` (channel 0), `TCC0` (channel 0) |
+| `D17`             | `PB07`       | `HUB75_ADDR_A`    |                      |                      |
+| `D18`             | `PB08`       | `HUB75_ADDR_B`    |                      |                      |
+| `D19`             | `PB09`       | `HUB75_ADDR_C`    |                      |                      |
+| `D20`             | `PB15`       | `HUB75_ADDR_D`    |                      | `TCC4` (channel 1), `TCC0` (channel 3) |
+| `D21`             | `PB13`       | `HUB75_ADDR_E`    |                      | `TCC3` (channel 1), `TCC0` (channel 1) |
+| `D22`             | `PA02`       | `A0`              |                      |                      |
+| `D23`             | `PA05`       | `D48`, `A1`, `SPI1_SCK_PIN` |                      |                      |
+| `D24`             | `PA04`       | `D49`, `A2`, `SPI1_SDO_PIN` |                      |                      |
+| `D25`             | `PA06`       | `A3`              |                      |                      |
+| `D26`             | `PA07`       | `D50`, `A4`, `SPI1_SDI_PIN` |                      |                      |
+| `D27`             | `PA12`       | `UART2_RX_PIN`, `NINA_RX` |                      | `TCC0` (channel 6), `TCC1` (channel 2) |
+| `D28`             | `PA13`       | `UART2_TX_PIN`, `NINA_TX` |                      | `TCC0` (channel 7), `TCC1` (channel 3) |
+| `D29`             | `PA20`       | `NINA_GPIO0`      |                      | `TCC1` (channel 4), `TCC0` (channel 0) |
+| `D30`             | `PA21`       | `NINA_RESETN`     |                      | `TCC1` (channel 5), `TCC0` (channel 1) |
+| `D31`             | `PA22`       | `NINA_ACK`        | `I2C0` (SDA)         | `TCC1` (channel 6), `TCC0` (channel 2) |
+| `D32`             | `PA18`       | `NINA_RTS`        |                      | `TCC1` (channel 2), `TCC0` (channel 6) |
+| `D33`             | `PB17`       | `NINA_CS`         |                      | `TCC3` (channel 1), `TCC0` (channel 5) |
+| `D34`             | `PA16`       | `SPI0_SCK_PIN`, `SPI_SCK_PIN`, `NINA_SCK` |                      | `TCC1` (channel 0), `TCC0` (channel 4) |
+| `D35`             | `PA17`       | `SPI0_SDI_PIN`, `SPI_SDI_PIN`, `NINA_SDI` |                      | `TCC1` (channel 1), `TCC0` (channel 5) |
+| `D36`             | `PA19`       | `SPI0_SDO_PIN`, `SPI_SDO_PIN`, `NINA_SDO` |                      | `TCC1` (channel 3), `TCC0` (channel 7) |
+| `D38`             | `PA24`       | `USBCDC_DM_PIN`, `UART0_RX_PIN` |                      | `TCC2` (channel 2)   |
+| `D39`             | `PA25`       | `USBCDC_DP_PIN`, `UART0_TX_PIN` |                      | `TCC2` (channel 3)   |
+| `D40`             | `PA03`       |                   |                      |                      |
+| `D41`             | `PB10`       | `QSPI_SCK`        |                      | `TCC0` (channel 4), `TCC1` (channel 0) |
+| `D42`             | `PB11`       | `QSPI_CS`         |                      | `TCC0` (channel 5), `TCC1` (channel 1) |
+| `D43`             | `PA08`       | `QSPI_DATA0`      |                      | `TCC0` (channel 0), `TCC1` (channel 4) |
+| `D44`             | `PA09`       | `QSPI_DATA1`      |                      | `TCC0` (channel 1), `TCC1` (channel 5) |
+| `D45`             | `PA10`       | `QSPI_DATA2`      |                      | `TCC0` (channel 2), `TCC1` (channel 6) |
+| `D46`             | `PA11`       | `QSPI_DATA3`      |                      | `TCC0` (channel 3), `TCC1` (channel 7) |
+| `D47`             | `PA27`       |                   |                      |                      |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Adafruit Matrix Portal M4](../machine/matrix-portal-m4)
+
+## Flashing
+
+### UF2
+
+The Adafruit Matrix Portal M4 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Plug your Matrix Portal M4 into your computer's USB port.
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=matrixportal-m4 [PATH TO YOUR PROGRAM]
+    ```
+
+- The Matrix Portal M4 board should restart and then begin running your program.
+
+### Troubleshooting
+
+If you have troubles getting your Matrix Portal M4 board to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the Matrix Portal M4 board ready to receive code.
+- The Matrix Portal M4 board will appear to your computer like a USB drive.
+- Now try running the command as above:
+
+    ```shell
+    tinygo flash -target=matrixportal-m4 [PATH TO YOUR PROGRAM]
+    ```
+
+Once you have updated your Matrix Portal M4 board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You can use the USB port to the Matrix Portal M4 as a serial port. `UART0` refers to this connection.
diff --git a/content/docs/reference/microcontrollers/metro-m4-airlift.md b/content/docs/reference/microcontrollers/metro-m4-airlift.md
new file mode 100644
index 00000000..d8f21b43
--- /dev/null
+++ b/content/docs/reference/microcontrollers/metro-m4-airlift.md
@@ -0,0 +1,104 @@
+---
+title: "Adafruit Metro M4 Express AirLift"
+weight: 3
+---
+
+The [Adafruit Metro M4 Express AirLift](https://www.adafruit.com/product/4000) is an ARM development board based on the Atmel [ATSAMD51J19](https://www.microchip.com/wwwproducts/en/ATSAMD51J19) family of SoC that has Arduino shield compatible form factor, and a built-in EspressIf ESP32 Wi-Fi Co processor.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `D0`              | `PA23`       | `UART_RX_PIN`     | `I2C0` (SCL)         | `TCC1` (channel 7), `TCC0` (channel 3) |
+| `D1`              | `PA22`       | `UART_TX_PIN`     | `I2C0` (SDA)         | `TCC1` (channel 6), `TCC0` (channel 2) |
+| `D2`              | `PB17`       |                   |                      | `TCC3` (channel 1), `TCC0` (channel 5) |
+| `D3`              | `PB16`       |                   |                      | `TCC3` (channel 0), `TCC0` (channel 4) |
+| `D4`              | `PB13`       |                   |                      | `TCC3` (channel 1), `TCC0` (channel 1) |
+| `D5`              | `PB14`       |                   |                      | `TCC4` (channel 0), `TCC0` (channel 2) |
+| `D6`              | `PB15`       |                   |                      | `TCC4` (channel 1), `TCC0` (channel 3) |
+| `D7`              | `PB12`       |                   |                      | `TCC3` (channel 0), `TCC0` (channel 0) |
+| `D8`              | `PA21`       |                   |                      | `TCC1` (channel 5), `TCC0` (channel 1) |
+| `D9`              | `PA20`       |                   |                      | `TCC1` (channel 4), `TCC0` (channel 0) |
+| `D10`             | `PA18`       |                   |                      | `TCC1` (channel 2), `TCC0` (channel 6) |
+| `D11`             | `PA19`       | `SPI1_SDO_PIN`    |                      | `TCC1` (channel 3), `TCC0` (channel 7) |
+| `D12`             | `PA17`       | `SPI1_SCK_PIN`    |                      | `TCC1` (channel 1), `TCC0` (channel 5) |
+| `D13`             | `PA16`       | `LED`, `SPI1_SDI_PIN` |                      | `TCC1` (channel 0), `TCC0` (channel 4) |
+| `D40`             | `PB22`       | `WS2812`          |                      |                      |
+| `A0`              | `PA02`       |                   |                      |                      |
+| `A1`              | `PA05`       |                   |                      |                      |
+| `A2`              | `PB06`       |                   |                      |                      |
+| `A3`              | `PB00`       |                   |                      |                      |
+| `A4`              | `PB08`       |                   |                      |                      |
+| `A5`              | `PB09`       |                   |                      |                      |
+| `USBCDC_DM_PIN`   | `PA24`       |                   |                      | `TCC2` (channel 2)   |
+| `USBCDC_DP_PIN`   | `PA25`       |                   |                      | `TCC2` (channel 3)   |
+| `UART2_TX_PIN`    | `PA04`       | `NINA_TX`         |                      |                      |
+| `UART2_RX_PIN`    | `PA07`       | `NINA_RX`         |                      |                      |
+| `NINA_CS`         | `PA15`       |                   |                      | `TCC2` (channel 1), `TCC1` (channel 3) |
+| `NINA_ACK`        | `PB04`       | `NINA_CTS`        |                      |                      |
+| `NINA_GPIO0`      | `PB01`       | `NINA_RTS`        |                      |                      |
+| `NINA_RESETN`     | `PB05`       |                   |                      |                      |
+| `SDA_PIN`         | `PB02`       |                   |                      | `TCC2` (channel 2)   |
+| `SCL_PIN`         | `PB03`       |                   |                      | `TCC2` (channel 3)   |
+| `SPI0_SCK_PIN`    | `PA13`       | `NINA_SCK`        |                      | `TCC0` (channel 7), `TCC1` (channel 3) |
+| `SPI0_SDO_PIN`    | `PA12`       | `NINA_SDO`        |                      | `TCC0` (channel 6), `TCC1` (channel 2) |
+| `SPI0_SDI_PIN`    | `PA14`       | `NINA_SDI`        |                      | `TCC2` (channel 0), `TCC1` (channel 2) |
+| `QSPI_SCK`        | `PB10`       |                   |                      | `TCC0` (channel 4), `TCC1` (channel 0) |
+| `QSPI_CS`         | `PB11`       |                   |                      | `TCC0` (channel 5), `TCC1` (channel 1) |
+| `QSPI_DATA0`      | `PA08`       |                   |                      | `TCC0` (channel 0), `TCC1` (channel 4) |
+| `QSPI_DATA1`      | `PA09`       |                   |                      | `TCC0` (channel 1), `TCC1` (channel 5) |
+| `QSPI_DATA2`      | `PA10`       |                   |                      | `TCC0` (channel 2), `TCC1` (channel 6) |
+| `QSPI_DATA3`      | `PA11`       |                   |                      | `TCC0` (channel 3), `TCC1` (channel 7) |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Adafruit Metro M4 Airlift](../machine/metro-m4-airlift)
+
+## Flashing
+
+### UF2
+
+The Metro M4 Express comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Plug your Metro M4 Express into your computer's USB port.
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=metro-m4-airlift [PATH TO YOUR PROGRAM]
+    ```
+
+- The Metro M4 Express board should restart and then begin running your program.
+
+### Troubleshooting
+
+If you have troubles getting your Metro M4 Express board to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the Metro M4 Express board ready to receive code.
+- The Metro M4 Express board will appear to your computer like a USB drive.
+- Now try running the command as above:
+
+    ```shell
+    tinygo flash -target=metro-m4-airlift [PATH TO YOUR PROGRAM]
+    ```
+
+Once you have updated your Metro M4 Express board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You can use the USB port to the Metro M4 Express as a serial port. `UART0` refers to this connection.
+
+The Neopixel LED on the Metro M4 Express can be accessed using the [WS2812](https://pkg.go.dev/tinygo.org/x/drivers/ws2812) driver via the `PB22` pin
diff --git a/content/microcontrollers/bbc-microbit.md b/content/docs/reference/microcontrollers/microbit.md
similarity index 59%
rename from content/microcontrollers/bbc-microbit.md
rename to content/docs/reference/microcontrollers/microbit.md
index 0af08fa7..acc1573e 100644
--- a/content/microcontrollers/bbc-microbit.md
+++ b/content/docs/reference/microcontrollers/microbit.md
@@ -11,11 +11,44 @@ The BBC [micro:bit](https://microbit.org) is a tiny programmable computer design
 | --------- | ------------- | ----- |
 | GPIO      | YES | YES |
 | UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | Not yet |
-| PWM      | Software support | Not yet |
-| Bluetooth      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | Software support | Not yet |
+| USBDevice | NO  | NO  |
+| Bluetooth | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `P0`              | `P0_03`      | `ADC0`            |
+| `P1`              | `P0_02`      | `ADC1`            |
+| `P2`              | `P0_01`      | `ADC2`            |
+| `P3`              | `P0_04`      | `LED_COL_1`       |
+| `P4`              | `P0_05`      | `LED_COL_2`       |
+| `P5`              | `P0_17`      | `BUTTONA`, `BUTTON` |
+| `P6`              | `P0_12`      | `LED_COL_9`       |
+| `P7`              | `P0_11`      | `LED_COL_8`       |
+| `P8`              | `P0_18`      |                   |
+| `P9`              | `P0_10`      | `LED_COL_7`       |
+| `P10`             | `P0_06`      | `LED_COL_3`       |
+| `P11`             | `P0_26`      | `BUTTONB`         |
+| `P12`             | `P0_20`      |                   |
+| `P13`             | `P0_23`      | `SPI0_SCK_PIN`    |
+| `P14`             | `P0_22`      | `SPI0_SDI_PIN`    |
+| `P15`             | `P0_21`      | `SPI0_SDO_PIN`    |
+| `P16`             | `P0_16`      |                   |
+| `UART_TX_PIN`     | `P0_24`      |                   |
+| `UART_RX_PIN`     | `P0_25`      |                   |
+| `SDA_PIN`         | `P0_30`      |                   |
+| `SCL_PIN`         | `P0_00`      |                   |
+| `LED_COL_4`       | `P0_07`      |                   |
+| `LED_COL_5`       | `P0_08`      |                   |
+| `LED_COL_6`       | `P0_09`      |                   |
+| `LED_ROW_1`       | `P0_13`      |                   |
+| `LED_ROW_2`       | `P0_14`      |                   |
+| `LED_ROW_3`       | `P0_15`      |                   |
 
 ## Machine Package Docs
 
diff --git a/content/docs/reference/microcontrollers/nano-33-ble-sense.md b/content/docs/reference/microcontrollers/nano-33-ble-sense.md
new file mode 100644
index 00000000..6fbd5958
--- /dev/null
+++ b/content/docs/reference/microcontrollers/nano-33-ble-sense.md
@@ -0,0 +1,19 @@
+---
+title: "Arduino Nano 33 BLE Sense"
+weight: 3
+---
+
+The [Arduino Nano 33 BLE Sense](https://store.arduino.cc/arduino-nano-33-ble-sense) is a very small ARM development board based on the Nordic Semiconductor [nrf52840](https://www.nordicsemi.com/eng/Products/nRF52840) processor.
+
+This is the same board as [Arduino Nano 33 BLE]({{<ref "nano-33-ble.md">}}) but
+with additional onboard sensors (see below).
+
+Flash this board exactly the same way as
+[Arduino Nano 33 BLE]({{<ref "nano-33-ble.md">}}) (target name is the same too).
+
+## Additional onboard sensors
+
+* Proximity [APDS9960](https://github.com/tinygo-org/drivers/tree/release/apds9960)
+* Pressure [LPS22HB](https://github.com/tinygo-org/drivers/tree/release/lps22hb)
+* Humidity [HTS221](https://github.com/tinygo-org/drivers/tree/release/hts221)
+* Microphone [MP34DT06JTR](https://github.com/tinygo-org/drivers/tree/release/microphone)
diff --git a/content/docs/reference/microcontrollers/nano-33-ble.md b/content/docs/reference/microcontrollers/nano-33-ble.md
new file mode 100644
index 00000000..328dcc90
--- /dev/null
+++ b/content/docs/reference/microcontrollers/nano-33-ble.md
@@ -0,0 +1,127 @@
+---
+title: "Arduino Nano 33 BLE"
+weight: 3
+---
+
+The [Arduino Nano33 BLE](https://store.arduino.cc/arduino-nano-33-ble) is a very small ARM development board based on the Nordic Semiconductor [nrf52840](https://www.nordicsemi.com/eng/Products/nRF52840) processor.
+
+There is also the [Arduino Nano33 BLE Sense]({{<ref "nano-33-ble-sense">}})
+which is the exact same board but with additional onboard sensors.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `D2`              | `P1_11`      |                   |
+| `D3`              | `P1_12`      |                   |
+| `D4`              | `P1_15`      |                   |
+| `D5`              | `P1_13`      |                   |
+| `D6`              | `P1_14`      |                   |
+| `D7`              | `P0_23`      |                   |
+| `D8`              | `P0_21`      |                   |
+| `D9`              | `P0_27`      |                   |
+| `D10`             | `P1_02`      |                   |
+| `D11`             | `P1_01`      | `SPI0_SDO_PIN`    |
+| `D12`             | `P1_08`      | `SPI0_SDI_PIN`    |
+| `D13`             | `P0_13`      | `LED`, `LED_BUILTIN`, `SPI0_SCK_PIN` |
+| `A0`              | `P0_04`      |                   |
+| `A1`              | `P0_05`      |                   |
+| `A2`              | `P0_30`      |                   |
+| `A3`              | `P0_29`      |                   |
+| `A4`              | `P0_31`      | `SDA0_PIN`        |
+| `A5`              | `P0_02`      | `SCL0_PIN`        |
+| `A6`              | `P0_28`      |                   |
+| `A7`              | `P0_03`      |                   |
+| `LED1`            | `P0_24`      | `LED_RED`         |
+| `LED2`            | `P0_16`      | `LED_GREEN`       |
+| `LED3`            | `P0_06`      | `LED_BLUE`        |
+| `LED_PWR`         | `P1_09`      |                   |
+| `UART_RX_PIN`     | `P1_10`      |                   |
+| `UART_TX_PIN`     | `P1_03`      |                   |
+| `SDA_PIN`         | `P0_14`      | `SDA1_PIN`        |
+| `SCL_PIN`         | `P0_15`      | `SCL1_PIN`        |
+| `I2C_PULLUP`      | `P1_00`      |                   |
+| `APDS_INT`        | `P0_19`      |                   |
+| `LSM_PWR`         | `P0_22`      | `LPS_PWR`, `HTS_PWR` |
+| `MIC_PWR`         | `P0_17`      |                   |
+| `MIC_CLK`         | `P0_26`      |                   |
+| `MIC_DIN`         | `P0_25`      |                   |
+
+## Onboard sensors
+
+* 9-axis IMU: [LSM9DS1](https://github.com/tinygo-org/drivers/tree/release/lsm9ds1)
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Arduino Nano33 BLE](../machine/nano-33-ble)
+
+## Installing BOSSA
+
+In order to flash your TinyGo programs onto the Arduino Nano33 BLE board, you will need to install the "bossac_arduino2" command line utility which is a special build of the [BOSSA command line utilities](https://github.com/shumatech/BOSSA).
+
+### macOS
+
+If you have a Mac computer with an Intel processor, download the `bossac_arduino2` program from http://downloads.arduino.cc/tools/bossac-1.9.1-arduino2-osx.tar.gz
+
+Extract the downloaded file to a directory on your computer.
+
+Make sure to add that directory into your PATH.
+
+### Linux
+
+Download the `bossac_arduino2` program from http://downloads.arduino.cc/tools/bossac-1.9.1-arduino2-linux64.tar.gz
+
+Extract the downloaded file to a directory on your computer.
+
+Make sure to add that directory into your PATH.
+
+### Windows
+
+Download the `bossac_arduino2` program from http://downloads.arduino.cc/tools/bossac-1.9.1-arduino2-windows.tar.gz
+
+Extract the downloaded file to a directory on your computer.
+
+Make sure to add that directory into your PATH.
+
+## Flashing
+
+Once you have installed the needed BOSSA command line utility, as in the previous section, you are ready to build and flash code to your Arduino Nano33 BLE board.
+
+### CLI Flashing
+
+- Plug your Arduino Nano33 BLE board into your computer's USB port.
+- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the Arduino Nano33 BLE with the blinky1 example:
+
+    ```shell
+    tinygo flash -target=nano-33-ble examples/blinky1
+    ```
+
+- The Arduino Nano33 BLE board should restart and then begin running your program.
+
+### Troubleshooting
+
+Instructions needed here.
+
+## Bluetooth
+
+Nordic Semiconductor's SoftDevice (s140v7) must be flashed first to enable use of [bluetooth](https://github.com/tinygo-org/bluetooth) on this board.
+
+SoftDevice overwrites original bootloader and flashing method described above is not available anymore.
+Instead, please use [debug]({{<ref "../../guides/debugging.md">}}) probe and
+flash your code with `nano-33-ble-s140v7` target.
+
+## Notes
+
+You can use the USB port to the Arduino Nano33 BLE as a serial port. `UART0` refers to this connection.
diff --git a/content/docs/reference/microcontrollers/nano-rp2040.md b/content/docs/reference/microcontrollers/nano-rp2040.md
new file mode 100644
index 00000000..e1d665de
--- /dev/null
+++ b/content/docs/reference/microcontrollers/nano-rp2040.md
@@ -0,0 +1,88 @@
+---
+title: "Arduino Nano RP2040 Connect"
+weight: 3
+---
+
+The [Nano RP2040 Connect](https://store.arduino.cc/nano-rp2040-connect) is a tiny development board based on the Raspberry Pi [RP2040](https://datasheets.raspberrypi.org/rp2040/rp2040-datasheet.pdf) microcontroller. 
+
+Peripherals: 
+- NINA-W102 chip with [wifinina](https://github.com/tinygo-org/drivers/tree/release/wifinina) firmware (wifi and bluetooth)
+- [lsm6dsox](https://github.com/tinygo-org/drivers/tree/release/lsm6dsox) IMU chip (acceleration, rotation and temperature)
+- microphone
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `D2`              | `GPIO25`     |                   |                      | `PWM4` (channel B)   |
+| `D3`              | `GPIO15`     |                   | `I2C1` (SCL)         | `PWM7` (channel B)   |
+| `D4`              | `GPIO16`     |                   | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `D5`              | `GPIO17`     |                   | `I2C0` (SCL)         | `PWM0` (channel B)   |
+| `D6`              | `GPIO18`     | `I2C1_SDA_PIN`    | `I2C1` (SDA)         | `PWM1` (channel A)   |
+| `D7`              | `GPIO19`     | `I2C1_SCL_PIN`    | `I2C1` (SCL)         | `PWM1` (channel B)   |
+| `D8`              | `GPIO20`     |                   | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `D9`              | `GPIO21`     |                   | `I2C0` (SCL)         | `PWM2` (channel B)   |
+| `D10`             | `GPIO5`      |                   | `I2C0` (SCL)         | `PWM2` (channel B)   |
+| `D11`             | `GPIO7`      | `SPI0_SDO_PIN`    | `I2C1` (SCL)         | `PWM3` (channel B)   |
+| `D12`             | `GPIO4`      | `SPI0_SDI_PIN`    | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `D13`             | `GPIO6`      | `LED`, `SPI0_SCK_PIN` | `I2C1` (SDA)         | `PWM3` (channel A)   |
+| `D14`             | `GPIO26`     | `A0`, `ADC0`      | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `D15`             | `GPIO27`     | `A1`, `ADC1`      | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `D16`             | `GPIO28`     | `A2`, `ADC2`      |                      | `PWM6` (channel A)   |
+| `D17`             | `GPIO29`     | `A3`, `ADC3`      |                      | `PWM6` (channel B)   |
+| `D18`             | `GPIO12`     | `I2C0_SDA_PIN`    | `I2C0` (SDA)         | `PWM6` (channel A)   |
+| `D19`             | `GPIO13`     | `I2C0_SCL_PIN`    | `I2C0` (SCL)         | `PWM6` (channel B)   |
+| `SPI1_SCK_PIN`    | `GPIO22`     | `SPI1_SDO_PIN`, `SPI1_SDI_PIN` |                      | `PWM3` (channel A)   |
+| `NINA_SCK`        | `GPIO14`     |                   | `I2C1` (SDA)         | `PWM7` (channel A)   |
+| `NINA_SDO`        | `GPIO11`     | `NINA_RTS`        | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `NINA_SDI`        | `GPIO8`      | `NINA_TX`         | `I2C0` (SDA)         | `PWM4` (channel A)   |
+| `NINA_CS`         | `GPIO9`      | `NINA_RX`         | `I2C0` (SCL)         | `PWM4` (channel B)   |
+| `NINA_ACK`        | `GPIO10`     | `NINA_CTS`        | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `NINA_GPIO0`      | `GPIO2`      |                   | `I2C1` (SDA)         | `PWM1` (channel A)   |
+| `NINA_RESETN`     | `GPIO3`      |                   | `I2C1` (SCL)         | `PWM1` (channel B)   |
+| `UART0_TX_PIN`    | `GPIO0`      | `UART_TX_PIN`     | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `UART0_RX_PIN`    | `GPIO1`      | `UART_RX_PIN`     | `I2C0` (SCL)         | `PWM0` (channel B)   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Nano RP2040](../machine/nano-rp2040)
+
+## Flashing
+
+### UF2
+
+The Nano RP2040 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=nano-rp2040 [PATH TO YOUR PROGRAM]
+    ```
+
+- The Nano RP2040 board should restart and run your program.
+
+### Troubleshooting
+
+Any troubleshooting tips go here.
+
+## Notes
+
+You can use the USB port to the Nano RP2040 as a serial port.
+
+TinyGo has support for the RP2040's on-board Programmable Input/Output (PIO) block.
+
+For more informantion, see [https://github.com/tinygo-org/pio](https://github.com/tinygo-org/pio)
diff --git a/content/docs/reference/microcontrollers/nicenano.md b/content/docs/reference/microcontrollers/nicenano.md
new file mode 100644
index 00000000..2db915bf
--- /dev/null
+++ b/content/docs/reference/microcontrollers/nicenano.md
@@ -0,0 +1,132 @@
+---
+title: "nice!nano"
+weight: 3
+---
+
+The [nice!nano](https://nicekeyboards.com/products/nice-nano-v1-0) is a wireless, BLE enabled replacement for the Pro Micro powered by the Nordic Semiconductor [nrf52840](https://www.nordicsemi.com/eng/Products/nRF52840) processor.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+| Bluetooth | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `D006`            | `P0_06`      | `UART_RX_PIN`     |
+| `D008`            | `P0_08`      | `UART_TX_PIN`     |
+| `D017`            | `P0_17`      | `SDA_PIN`         |
+| `D020`            | `P0_20`      | `SCL_PIN`         |
+| `D022`            | `P0_22`      | `SPI0_SCK_PIN`    |
+| `D024`            | `P0_24`      | `SPI0_SDO_PIN`    |
+| `D100`            | `P1_00`      | `SPI0_SDI_PIN`    |
+| `D011`            | `P0_11`      |                   |
+| `D104`            | `P1_04`      |                   |
+| `D106`            | `P1_06`      |                   |
+| `D004`            | `P0_04`      | `AIN2`            |
+| `D013`            | `P0_13`      |                   |
+| `D115`            | `P1_15`      |                   |
+| `D113`            | `P1_13`      |                   |
+| `D031`            | `P0_31`      | `AIN7`            |
+| `D029`            | `P0_29`      | `AIN5`            |
+| `D002`            | `P0_02`      | `AIN0`            |
+| `D111`            | `P1_11`      |                   |
+| `D010`            | `P0_10`      |                   |
+| `D009`            | `P0_09`      |                   |
+| `D026`            | `P0_26`      |                   |
+| `D012`            | `P0_12`      |                   |
+| `D101`            | `P1_01`      |                   |
+| `D102`            | `P1_02`      |                   |
+| `D107`            | `P1_07`      |                   |
+| `LED`             | `P0_15`      |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the nice!nano](../machine/nicenano)
+
+## Flashing
+
+### UF2
+
+The nice!nano comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+**PLEASE NOTE** that for a good experience using TinyGo on your board you must be running version 0.4.1 or above of the UF2 bootloader on the board. For more information, [see below](#updating-the-uf2-bootloader)
+
+### CLI Flashing
+
+- Plug your nice!nano into your computer's USB port.
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=nicenano [PATH TO YOUR PROGRAM]
+    ```
+
+- The nice!nano board should restart and then begin running your program.
+
+### Troubleshooting
+
+If you have troubles getting your nice!nano board to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the nice!nano board ready to receive code.
+- The nicenano board will appear to your computer like a USB drive.
+- Now try running the command:
+
+    ```shell
+    tinygo flash -target=nicenano [PATH TO YOUR PROGRAM]
+    ```
+
+Once you have updated your nice!nano board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You can use the USB port to the nice!nano as a serial port. `UART0` refers to this connection.
+
+Bluetooth support is available for the nice!nano board. See https://github.com/tinygo-org/bluetooth for more information.
+
+## Updating the UF2 bootloader
+
+This board uses a UF2 bootloader created by Adafruit: https://github.com/adafruit/Adafruit_nRF52_Bootloader
+
+We recommend bootloader version 0.4.1 or above. You can check what version is installed on your board by double-clicking the button on the board to launch the bootloader. When you do this, a USB volume that should automatically be mounted on your computer. Check the file named "INFO_UF2.TXT" on that drive. The bootloader firmware version should be listed in that file, for example:
+
+```
+UF2 Bootloader 0.4.1 lib/nrfx (v2.0.0) lib/tinyusb (0.6.0-272-g4e6aa0d8) lib/uf2 (remotes/origin/configupdate-9-gadbb8c7)
+Model: Adafruit ItsyBitsy nRF52840 Express
+Board-ID: nRF52840-ItsyBitsy-revA
+SoftDevice: S140 version 6.1.1
+Date: Jan 19 2021
+```
+
+To update the bootloader, you will need to install the `adafruit-nrfutil` program. 
+
+You can install it by running:
+
+```shell
+pip3 install --user adafruit-nrfutil
+```
+
+Once you have installed the `adafruit-nrfutil` program, download the firmware here: 
+https://github.com/adafruit/Adafruit_nRF52_Bootloader/releases/download/0.4.1/nice_nano_bootloader-0.4.1.zip
+
+Unzip the files in this zip file and save them to a convenient location. 
+
+Plug in your board to your computer's USB port.
+
+Now we are ready to update the firmware. Run a command something like the following, adjusting for any difference based on where you have saved the files, and what your serial port is named:
+
+```shell
+ adafruit-nrfutil --verbose dfu serial --package nice_nano_bootloader-0.4.1_s140_6.1.1.zip -p /dev/ttyACM0 -b 115200 --singlebank --touch 1200
+```
+
+Note that you should be flashing the board using the zip file that was contained within the zip file that you downloaded, NOT the file that you downloaded.
+
+Once you have flashed the board with the `adafruit-nrfutil` it should restart the board with the new bootloader. You only need to do this update once, and then from that point on the new bootloader will be active.
diff --git a/content/microcontrollers/nintendo-switch.md b/content/docs/reference/microcontrollers/nintendoswitch.md
similarity index 84%
rename from content/microcontrollers/nintendo-switch.md
rename to content/docs/reference/microcontrollers/nintendoswitch.md
index e42ec82c..2376c9c1 100644
--- a/content/microcontrollers/nintendo-switch.md
+++ b/content/docs/reference/microcontrollers/nintendoswitch.md
@@ -11,10 +11,11 @@ The [Nintendo Switch](https://en.wikipedia.org/wiki/Nintendo_Switch) is a handhe
 | --------- | ------------- | ----- |
 | GPIO      | ? | ? |
 | UART      | ? | ? |
-| SPI      | ? | ? |
-| I2C      | ? | ? |
-| ADC      | ? | ? |
-| PWM      | ? | ? |
+| SPI       | ? | ? |
+| I2C       | ? | ? |
+| ADC       | ? | ? |
+| PWM       | ? | ? |
+| USBDevice | ? | ? |
 
 ## Machine Package Docs
 
@@ -24,7 +25,7 @@ The [Nintendo Switch](https://en.wikipedia.org/wiki/Nintendo_Switch) is a handhe
 
 You will need the `linkle` (https://github.com/MegatonHammer/linkle) program to convert to the NRO format needed by the Switch:
 
-You can use a Nintendo Switch software emulator such as yuzu (https://yuzu-emu.org/) to test your programs.
+You can use a Nintendo Switch software emulator such as [suyu https://suyu.dev/](https://suyu.dev/) to test your programs.
 
 ## Building code
 
diff --git a/content/microcontrollers/esp8266-nodemcu.md b/content/docs/reference/microcontrollers/nodemcu.md
similarity index 75%
rename from content/microcontrollers/esp8266-nodemcu.md
rename to content/docs/reference/microcontrollers/nodemcu.md
index b38dd46c..cb2c4b35 100644
--- a/content/microcontrollers/esp8266-nodemcu.md
+++ b/content/docs/reference/microcontrollers/nodemcu.md
@@ -11,12 +11,29 @@ The [Espressif ESP8266](https://www.espressif.com/en/products/socs/esp8266) Node
 | --------- | ------------- | ----- |
 | GPIO      | YES | YES |
 | UART      | YES | YES |
-| SPI      | YES | Not Yet |
-| I2C      | NO (software only) | NO |
-| ADC      | YES | Not Yet |
-| PWM      | YES | Not Yet |
+| SPI       | YES | Not yet |
+| I2C       | NO (software only) | Not yet |
+| ADC       | YES | YES |
+| PWM       | YES | Not yet |
+| USBDevice | NO  | NO  |
 | WiFi      | YES | Not Yet |
 
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `D0`              | `GPIO16`     |                   |
+| `D1`              | `GPIO5`      | `SCL_PIN`         |
+| `D2`              | `GPIO4`      | `SDA_PIN`         |
+| `D3`              | `GPIO0`      |                   |
+| `D4`              | `GPIO2`      | `LED`             |
+| `D5`              | `GPIO14`     | `SPI0_SCK_PIN`    |
+| `D6`              | `GPIO12`     | `SPI0_SDI_PIN`    |
+| `D7`              | `GPIO13`     | `SPI0_SDO_PIN`    |
+| `D8`              | `GPIO15`     | `SPI0_CS0_PIN`    |
+| `UART_TX_PIN`     | `GPIO1`      |                   |
+| `UART_RX_PIN`     | `GPIO3`      |                   |
+
 ## Machine Package Docs
 
 [Documentation for the machine package for the ESP8266 NodeMCU](../machine/nodemcu)
diff --git a/content/docs/reference/microcontrollers/nrf52840-mdk-usb-dongle.md b/content/docs/reference/microcontrollers/nrf52840-mdk-usb-dongle.md
new file mode 100644
index 00000000..f62fa9e7
--- /dev/null
+++ b/content/docs/reference/microcontrollers/nrf52840-mdk-usb-dongle.md
@@ -0,0 +1,63 @@
+---
+title: "Makerdiary nRF52840-MDK USB Dongle"
+weight: 3
+---
+
+The [nRF52840 MDK USB Dongle](https://wiki.makerdiary.com/nrf52840-mdk-usb-dongle/) (not to be confused with its sibling, the [nRF52840-MDK](https://wiki.makerdiary.com/nrf52840-mdk/)) is an open-source, micro development kit dongle for IoT applications based on the Nordic Semiconductor [nRF52840](https://www.nordicsemi.com/eng/Products/nRF52840) SoC chip.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+| Bluetooth | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `LED`             | `P0_22`      | `LED_GREEN`       |
+| `LED_RED`         | `P0_23`      |                   |
+| `LED_BLUE`        | `P0_24`      |                   |
+| `BUTTON`          | `P0_18`      |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the nRF52840-MDK-USB-Dongle](../machine/nrf52840-mdk-usb-dongle)
+
+## Flashing
+
+### UF2
+
+The nRF52840 MDK USB Dongle currently ships with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed. However, previously (pre mid-2020) it was also shipped with Open Bootloader. To use TinyGo with the nRF52840 MDK USB Dongle, please [upgrade to the UF2 bootloader](https://wiki.makerdiary.com/nrf52840-mdk-usb-dongle/programming/#upgrade-to-uf2-bootloader-from-open-bootloader).
+
+### SoftDevice
+
+TinyGo uses the S140 v6 [SoftDevice](https://infocenter.nordicsemi.com/topic/ug_gsg_ses/UG/gsg/softdevices.html) (proprietary firmware) for Bluetooth support and requires it to be installed before you can run TinyGo programs.
+
+Some C++ examples in the [nRF52840 MDK USB Dongle repository](https://github.com/makerdiary/nrf52840-mdk-usb-dongle), like the [C++ blinky](https://github.com/makerdiary/nrf52840-mdk-usb-dongle/tree/master/examples/nrf5-sdk/blinky) example, do not use a SoftDevice and when flashed will be placed at the location where the SoftDevice is usually located, overwriting it in the process.
+
+To install the S140 v6 SoftDevice, please follow the SoftDevice part of the ["Running examples that use a SoftDevice"](https://wiki.makerdiary.com/nrf52840-mdk-usb-dongle/nrf5-sdk/#running-examples-that-use-a-softdevice) instructions on the nRF52840 MDK USB Dongle wiki.
+
+### CLI Flashing
+
+- Enter DFU mode by holding the dongle's RESET/USR button while plugging it into your computer's USB port. A flash drive with the name MDK-DONGLE will appear.
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=nrf52840-mdk-usb-dongle [PATH TO YOUR PROGRAM]
+    ```
+
+## Notes
+
+You can use the USB port of the nRF52840 MDK USB Dongle as a serial port. `UART0` refers to this connection.
+
+The button (pin 18) on the nRF52840 MDK USB Dongle can be to be configured as a reset-button or GPIO pin through the `PSELRESET[0]/[1]` UICR registers. When it is configured as reset instead of as GPIO, you won't be able to use the button in your code as pressing it will reset the nrf52840. To set the `PSELRESET[0]/[1]` UICR registers back to their default value (disabled), please flash the [pselreset erase example](https://github.com/makerdiary/nrf52840-mdk-usb-dongle/tree/master/examples/nrf5-sdk/pselreset_erase) using [these instructions](https://wiki.makerdiary.com/nrf52840-mdk-usb-dongle/programming/#dfu-via-uf2-bootloader) on the nRF52840 MDK USB Dongle wiki.
+
+Bluetooth support is now available for nRF52840 boards. See https://github.com/tinygo-org/bluetooth for more information.
diff --git a/content/docs/reference/microcontrollers/nrf52840-mdk.md b/content/docs/reference/microcontrollers/nrf52840-mdk.md
new file mode 100644
index 00000000..16844ae6
--- /dev/null
+++ b/content/docs/reference/microcontrollers/nrf52840-mdk.md
@@ -0,0 +1,64 @@
+---
+title: "Makerdiary nRF52840-MDK"
+weight: 3
+---
+
+The [nRF52840-MDK](https://wiki.makerdiary.com/nrf52840-mdk/) (not to be confused with its sibling, the [nRF52840-MDK-USB-Dongle](https://wiki.makerdiary.com/nrf52840-mdk-usb-dongle/)) is an open-source, micro development kit for IoT applications based on the Nordic Semiconductor [nRF52840](https://www.nordicsemi.com/eng/Products/nRF52840) SoC chip.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+| Bluetooth | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `LED_GREEN`       | `P0_22`      | `LED`             |
+| `LED_RED`         | `P0_23`      |                   |
+| `LED_BLUE`        | `P0_24`      |                   |
+| `UART_TX_PIN`     | `P0_20`      |                   |
+| `UART_RX_PIN`     | `P0_19`      |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the nRF52840-MDK](../machine/nrf52840-mdk)
+
+## Flashing
+
+There are two options to flash the nRF52840-MDK board.
+
+### OpenOCD (Recommended)
+
+You must install [OpenOCD](http://openocd.org/) before you will be able to flash the nRF52840-MDK board with your TinyGo code.
+You should check [OpenOCD Documentation](http://openocd.org/Documentation) for installation and configuration instructions.
+
+Once you have installed it correctly, you will be able to flash the nRF52840-MDK board with your TinyGo code.
+
+- Plug your nRF52840-MDK into your computer's USB port.
+- Build and flash your TinyGo program using `tinygo flash -target=nrf52840-mdk`
+
+### nrfjprog/J-Link
+
+Programs can be loaded onto the nRF52840-MDK board using the `nrfjprog` command line utility program.
+
+First install the J-Link Software and Documentation Pack from Segger: [https://www.segger.com/downloads/jlink/#J-LinkSoftwareAndDocumentationPack](https://www.segger.com/downloads/jlink/#J-LinkSoftwareAndDocumentationPack)
+
+Then install the nRF5x Command-Line Tools: [https://docs.zephyrproject.org/latest/guides/tools/nordic_segger.html#nrf5x-command-line-tools-installation](https://docs.zephyrproject.org/latest/guides/tools/nordic_segger.html#nrf5x-command-line-tools-installation)
+
+Once you have installed both of these correctly, you will be able to flash the nRF52840-MDK board with your TinyGo code.
+
+- Plug your nRF52840-MDK into your computer's USB port.
+- Build and flash your TinyGo program using `tinygo flash -target=nrf52840-mdk -programmer command`
+
+## Notes
+
+Bluetooth support is now available for nRF52840 boards. See https://github.com/tinygo-org/bluetooth for more information.
diff --git a/content/microcontrollers/nucleo-f103rb.md b/content/docs/reference/microcontrollers/nucleo-f103rb.md
similarity index 61%
rename from content/microcontrollers/nucleo-f103rb.md
rename to content/docs/reference/microcontrollers/nucleo-f103rb.md
index bbb30235..a6751243 100644
--- a/content/microcontrollers/nucleo-f103rb.md
+++ b/content/docs/reference/microcontrollers/nucleo-f103rb.md
@@ -1,5 +1,5 @@
 ---
-title: "Nucleo F103RB"
+title: 'ST Micro "Nucleo" F103RB'
 weight: 3
 ---
 
@@ -13,8 +13,24 @@ The [Nucleo F103RB](https://www.st.com/en/evaluation-tools/nucleo-f103rb.html) i
 | UART      | YES | YES |
 | SPI       | YES | YES |
 | I2C       | YES | YES |
-| ADC       | YES | Not yet |
+| ADC       | YES | YES |
 | PWM       | YES | Not yet |
+| USBDevice | NO  | NO  |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `LED`             | `PA5`        | `LED_BUILTIN`, `LED_GREEN`, `SPI0_SCK_PIN` |
+| `BUTTON`          | `PC13`       | `BUTTON_USER`     |
+| `UART_TX_PIN`     | `PA2`        |                   |
+| `UART_RX_PIN`     | `PA3`        |                   |
+| `UART_ALT_TX_PIN` | `PD5`        |                   |
+| `UART_ALT_RX_PIN` | `PD6`        |                   |
+| `SPI0_SDI_PIN`    | `PA6`        |                   |
+| `SPI0_SDO_PIN`    | `PA7`        |                   |
+| `I2C0_SCL_PIN`    | `PB6`        |                   |
+| `I2C0_SDA_PIN`    | `PB7`        |                   |
 
 ## Machine Package Docs
 
diff --git a/content/docs/reference/microcontrollers/nucleo-f722ze.md b/content/docs/reference/microcontrollers/nucleo-f722ze.md
new file mode 100644
index 00000000..efb86bee
--- /dev/null
+++ b/content/docs/reference/microcontrollers/nucleo-f722ze.md
@@ -0,0 +1,49 @@
+---
+title: 'ST Micro "Nucleo" F722ZE'
+weight: 3
+---
+
+The [STM32 Nucleo F722ZE](https://www.st.com/en/evaluation-tools/nucleo-f722ze.html) is an ARM development board based on the ST Micro [STM32F722ZE](https://www.st.com/en/microcontrollers-microprocessors/stm32f722ze.html) SoC.
+
+It has 2 user buttons, and 3 user LEDs.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | Not yet |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | Not yet |
+| USBDevice | YES | Not yet |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `LED`             | `PB0`        | `LED_BUILTIN`, `LED_GREEN` |
+| `LED_BLUE`        | `PB7`        |                   |
+| `LED_RED`         | `PB14`       |                   |
+| `BUTTON`          | `PC13`       | `BUTTON_USER`     |
+| `UART_TX_PIN`     | `PD8`        |                   |
+| `UART_RX_PIN`     | `PD9`        |                   |
+| `SPI0_SCK_PIN`    | `PA5`        |                   |
+| `SPI0_SDI_PIN`    | `PA6`        |                   |
+| `SPI0_SDO_PIN`    | `PA7`        |                   |
+| `I2C0_SCL_PIN`    | `PB8`        |                   |
+| `I2C0_SDA_PIN`    | `PB9`        |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the STM32 Nucleo F722ZE](../machine/nucleo-f722ze)
+
+## Flashing
+
+### OpenOCD
+
+Programs are loaded onto the STM32 Nucleo F722ZE with the onboard [STLink v2](https://www.st.com/en/development-tools/st-link-v2.html) hardware programmer, using the `openocd` command line utility program to perform the board flashing. You must install [OpenOCD](http://openocd.org/) before you will be able to flash the STM32 Nucleo F722ZE board with your TinyGo code.
+
+- Plug your STM32 Nucleo F722ZE into your computer's USB port.
+- Build and flash your TinyGo program using `tinygo flash -target=nucleo-f722ze`
diff --git a/content/docs/reference/microcontrollers/nucleo-l031k6.md b/content/docs/reference/microcontrollers/nucleo-l031k6.md
new file mode 100644
index 00000000..55872df0
--- /dev/null
+++ b/content/docs/reference/microcontrollers/nucleo-l031k6.md
@@ -0,0 +1,59 @@
+---
+title: 'ST Micro "Nucleo" L031K6'
+weight: 3
+---
+
+The [STM32 Nucleo L031K6](https://www.st.com/en/evaluation-tools/nucleo-l031k6.html) is an ARM development board based on the ST Micro [STM32L031K6](https://www.st.com/en/microcontrollers-microprocessors/stm32l031k6.html) SoC.
+
+It has 2 user buttons, and 3 user LEDs.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | Not yet |
+| USBDevice | NO  | NO  |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `A0`              | `PA0`        | `BUTTON`          |
+| `A1`              | `PA1`        |                   |
+| `A2`              | `PA3`        |                   |
+| `A3`              | `PA4`        |                   |
+| `A4`              | `PA5`        |                   |
+| `A5`              | `PA6`        |                   |
+| `A6`              | `PA7`        |                   |
+| `A7`              | `PA2`        | `UART_TX_PIN`     |
+| `D0`              | `PA10`       |                   |
+| `D1`              | `PA9`        |                   |
+| `D2`              | `PA12`       |                   |
+| `D3`              | `PB0`        |                   |
+| `D4`              | `PB7`        | `I2C0_SCL_PIN`    |
+| `D5`              | `PB6`        | `I2C0_SDA_PIN`    |
+| `D6`              | `PB1`        |                   |
+| `D9`              | `PA8`        |                   |
+| `D10`             | `PA11`       |                   |
+| `D11`             | `PB5`        | `SPI1_SDI_PIN`, `SPI0_SDI_PIN` |
+| `D12`             | `PB4`        | `SPI1_SDO_PIN`, `SPI0_SDO_PIN` |
+| `D13`             | `PB3`        | `LED`, `LED_BUILTIN`, `LED_GREEN`, `SPI1_SCK_PIN`, `SPI0_SCK_PIN` |
+| `UART_RX_PIN`     | `PA15`       |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the STM32 Nucleo L031K6](../machine/nucleo-l031k6)
+
+## Flashing
+
+### OpenOCD
+
+Programs are loaded onto the STM32 Nucleo L031K6 with the onboard [STLink v2](https://www.st.com/en/development-tools/st-link-v2.html) hardware programmer, using the `openocd` command line utility program to perform the board flashing. You must install [OpenOCD](http://openocd.org/) before you will be able to flash the STM32 Nucleo L031K6 board with your TinyGo code.
+
+- Plug your STM32 Nucleo L031K6 into your computer's USB port.
+- Build and flash your TinyGo program using `tinygo flash -target=nucleo-l031k6`
diff --git a/content/docs/reference/microcontrollers/nucleo-l432kc.md b/content/docs/reference/microcontrollers/nucleo-l432kc.md
new file mode 100644
index 00000000..22aa70ae
--- /dev/null
+++ b/content/docs/reference/microcontrollers/nucleo-l432kc.md
@@ -0,0 +1,61 @@
+---
+title: 'ST Micro "Nucleo" L432KC'
+weight: 3
+---
+
+The [STM32 Nucleo L432KC](https://www.st.com/en/evaluation-tools/nucleo-l432kc.html) is an ARM development board based on the ST Micro [STM32L432KC](https://www.st.com/en/microcontrollers-microprocessors/stm32l432kc.html) SoC.
+
+It has 2 user buttons, and 3 user LEDs.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | Not yet |
+| USBDevice | NO  | NO  |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `A0`              | `PA0`        | `BUTTON`          |
+| `A1`              | `PA1`        |                   |
+| `A2`              | `PA3`        |                   |
+| `A3`              | `PA4`        |                   |
+| `A4`              | `PA5`        |                   |
+| `A5`              | `PA6`        |                   |
+| `A6`              | `PA7`        |                   |
+| `A7`              | `PA2`        | `UART_TX_PIN`     |
+| `D0`              | `PA10`       |                   |
+| `D1`              | `PA9`        |                   |
+| `D2`              | `PA12`       |                   |
+| `D3`              | `PB0`        |                   |
+| `D4`              | `PB7`        | `I2C0_SDA_PIN`    |
+| `D5`              | `PB6`        | `I2C0_SCL_PIN`    |
+| `D6`              | `PB1`        |                   |
+| `D7`              | `PC14`       |                   |
+| `D8`              | `PC15`       |                   |
+| `D9`              | `PA8`        |                   |
+| `D10`             | `PA11`       |                   |
+| `D11`             | `PB5`        | `SPI1_SDI_PIN`, `SPI0_SDI_PIN` |
+| `D12`             | `PB4`        | `SPI1_SDO_PIN`, `SPI0_SDO_PIN` |
+| `D13`             | `PB3`        | `LED`, `LED_BUILTIN`, `LED_GREEN`, `SPI1_SCK_PIN`, `SPI0_SCK_PIN` |
+| `UART_RX_PIN`     | `PA15`       |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the STM32 Nucleo L432KC](../machine/nucleo-l432kc)
+
+## Flashing
+
+### OpenOCD
+
+Programs are loaded onto the STM32 Nucleo L432KC with the onboard [STLink v2](https://www.st.com/en/development-tools/st-link-v2.html) hardware programmer, using the `openocd` command line utility program to perform the board flashing. You must install [OpenOCD](http://openocd.org/) before you will be able to flash the STM32 Nucleo L432KC board with your TinyGo code.
+
+- Plug your STM32 Nucleo L432KC into your computer's USB port.
+- Build and flash your TinyGo program using `tinygo flash -target=nucleo-l432kc`
diff --git a/content/docs/reference/microcontrollers/nucleo-l552ze.md b/content/docs/reference/microcontrollers/nucleo-l552ze.md
new file mode 100644
index 00000000..600c6ac9
--- /dev/null
+++ b/content/docs/reference/microcontrollers/nucleo-l552ze.md
@@ -0,0 +1,46 @@
+---
+title: 'ST Micro "Nucleo" L552ZE'
+weight: 3
+---
+
+The [STM32 Nucleo L552ZE](https://www.st.com/en/evaluation-tools/nucleo-l552ze-q.html) is an ARM development board based on the ST Micro [STM32L552ZE](https://www.st.com/en/microcontrollers-microprocessors/stm32l552ze.html) SoC.
+
+It has onboard ethernet, 2 user buttons, and 3 user LEDs.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | Not yet |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | Not yet |
+| USBDevice | YES | Not yet |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `LED_GREEN`       | `PC7`        | `LED_BUILTIN`, `LED` |
+| `LED_BLUE`        | `PB7`        |                   |
+| `LED_RED`         | `PA9`        |                   |
+| `BUTTON`          | `PC13`       | `BUTTON_USER`     |
+| `UART_TX_PIN`     | `PG7`        |                   |
+| `UART_RX_PIN`     | `PG8`        |                   |
+| `I2C0_SCL_PIN`    | `PB8`        |                   |
+| `I2C0_SDA_PIN`    | `PB9`        |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the STM32 Nucleo l552ze](../machine/nucleo-l552ze)
+
+## Flashing
+
+### OpenOCD
+
+Programs are loaded onto the STM32 Nucleo L552ZE with the onboard [STLink v2](https://www.st.com/en/development-tools/st-link-v2.html) hardware programmer, using the `openocd` command line utility program to perform the board flashing. You must install [OpenOCD](http://openocd.org/) before you will be able to flash the STM32 Nucleo L552ZE board with your TinyGo code.
+
+- Plug your STM32 Nucleo L552ZE into your computer's USB port.
+- Build and flash your TinyGo program using `tinygo flash -target=nucleo-l552ze`
diff --git a/content/docs/reference/microcontrollers/nucleo-wl55jc.md b/content/docs/reference/microcontrollers/nucleo-wl55jc.md
new file mode 100644
index 00000000..5e66ba8d
--- /dev/null
+++ b/content/docs/reference/microcontrollers/nucleo-wl55jc.md
@@ -0,0 +1,56 @@
+---
+title: "STM32 Nucleo WL55JC"
+weight: 3
+---
+
+The [STM32 Nucleo WL55JC](https://www.st.com/en/evaluation-tools/nucleo-wl55jc.html) is an ARM development board based on the ST Micro [STM32WL55JCI](https://www.st.com/en/microcontrollers-microprocessors/stm32wl55jc.html) SoC.
+
+It has onboard LoRa®, (G)FSK, (G)MSK, and BPSK as well as 3 user LEDs, 3 user buttons and 1 reset push-button
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | Not yet |
+| USBDevice | NO  | NO  |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `LED_BLUE`        | `PB15`       |                   |
+| `LED_GREEN`       | `PB9`        |                   |
+| `LED_RED`         | `PB11`       | `LED`             |
+| `BTN1`            | `PA0`        | `BUTTON`          |
+| `BTN2`            | `PA1`        |                   |
+| `BTN3`            | `PC6`        |                   |
+| `SPI0_NSS_PIN`    | `PA4`        |                   |
+| `SPI0_SCK_PIN`    | `PA5`        |                   |
+| `SPI0_SDO_PIN`    | `PA6`        |                   |
+| `SPI0_SDI_PIN`    | `PA7`        |                   |
+| `UART1_TX_PIN`    | `PB6`        |                   |
+| `UART1_RX_PIN`    | `PB7`        |                   |
+| `UART2_RX_PIN`    | `PA3`        | `UART_RX_PIN`     |
+| `UART2_TX_PIN`    | `PA2`        | `UART_TX_PIN`     |
+| `I2C1_SCL_PIN`    | `PA9`        | `I2C0_SCL_PIN`    |
+| `I2C1_SDA_PIN`    | `PA10`       | `I2C0_SDA_PIN`    |
+| `I2C2_SCL_PIN`    | `PA12`       |                   |
+| `I2C2_SDA_PIN`    | `PA11`       |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the STM32 Nucleo WL55JC](../machine/nucleo-wl55jc)
+
+## Flashing
+
+### OpenOCD
+
+Programs are loaded onto the STM32 Nucleo WL55JC with the onboard STLink hardware programmer, using the `openocd` command line utility program to perform the board flashing. You must install [OpenOCD](http://openocd.org/) before you will be able to flash the STM32 Nucleo WL55JC board with your TinyGo code.
+
+- Plug your STM32 Nucleo WL55JC into your computer's USB port.
+- Build and flash your TinyGo program using `tinygo flash -target=nucleo-wl55jc`
diff --git a/content/docs/reference/microcontrollers/p1am-100.md b/content/docs/reference/microcontrollers/p1am-100.md
new file mode 100644
index 00000000..aa49d1e1
--- /dev/null
+++ b/content/docs/reference/microcontrollers/p1am-100.md
@@ -0,0 +1,142 @@
+---
+title: "ProductivityOpen P1AM-100"
+weight: 3
+---
+
+The [ProductivityOpen P1AM-100](https://facts-engineering.github.io/modules/P1AM-100/P1AM-100.html) automation platform compatible with Productivity1000 Series I/O modules, P1AM Series shields, and Arduino MKR format shields. It is based on the Microchip [SAMD21G18](https://www.microchip.com/wwwproducts/en/ATSAMD21G18) family of processors. It also has a NINA-W102 chip onboard which provides an wireless communication abilities based on the popular ESP32 family of wireless chips from Espressif.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `D0`              | `PA22`       |                   |                      | `TCC0` (channel 0)   |
+| `D1`              | `PA23`       |                   |                      | `TCC0` (channel 1)   |
+| `D2`              | `PA10`       | `I2S_SCK_PIN`     |                      | `TCC1` (channel 0), `TCC0` (channel 2) |
+| `D3`              | `PA11`       | `I2S_WS_PIN`      |                      | `TCC1` (channel 1), `TCC0` (channel 3) |
+| `D4`              | `PB10`       |                   |                      | `TCC0` (channel 0)   |
+| `D5`              | `PB11`       |                   |                      | `TCC0` (channel 1)   |
+| `D6`              | `PA20`       |                   |                      | `TCC0` (channel 2)   |
+| `D7`              | `PA21`       |                   |                      | `TCC0` (channel 3)   |
+| `D8`              | `PA16`       | `SPI0_SDO_PIN`    |                      | `TCC2` (channel 0), `TCC0` (channel 2) |
+| `D9`              | `PA17`       | `SPI0_SCK_PIN`    |                      | `TCC2` (channel 1), `TCC0` (channel 3) |
+| `D10`             | `PA19`       | `SPI0_SDI_PIN`    |                      | `TCC0` (channel 3)   |
+| `D11`             | `PA08`       | `SDA_PIN`         | `I2C0` (SDA)         | `TCC0` (channel 0), `TCC1` (channel 2) |
+| `D12`             | `PA09`       | `SCL_PIN`         | `I2C0` (SCL)         | `TCC0` (channel 1), `TCC1` (channel 3) |
+| `D13`             | `PB23`       | `UART_RX_PIN`     |                      |                      |
+| `D14`             | `PB22`       | `UART_TX_PIN`     |                      |                      |
+| `D15`             | `PA02`       | `A0`              |                      |                      |
+| `D16`             | `PB02`       | `A1`              |                      |                      |
+| `D17`             | `PB03`       | `A2`              |                      |                      |
+| `D18`             | `PA04`       | `A3`, `BASE_SLAVE_SELECT_PIN` |                      | `TCC0` (channel 0)   |
+| `D19`             | `PA05`       | `A4`, `BASE_SLAVE_ACK_PIN` |                      | `TCC0` (channel 1)   |
+| `D20`             | `PA06`       | `A5`              |                      | `TCC1` (channel 0)   |
+| `D21`             | `PA07`       | `A6`, `I2S_SDO_PIN` |                      | `TCC1` (channel 1)   |
+| `SWITCH`          | `PA28`       |                   |                      |                      |
+| `LED`             | `PB08`       |                   |                      |                      |
+| `ADC_BATTERY`     | `PB09`       | `BASE_ENABLE_PIN` |                      |                      |
+| `USBCDC_DM_PIN`   | `PA24`       |                   |                      | `TCC1` (channel 2)   |
+| `USBCDC_DP_PIN`   | `PA25`       |                   |                      | `TCC1` (channel 3)   |
+| `USBCDC_HOST_ENABLE_PIN` | `PA18`       |                   |                      | `TCC0` (channel 2)   |
+| `SDCARD_SDI_PIN`  | `PA15`       |                   |                      | `TCC0` (channel 1)   |
+| `SDCARD_SDO_PIN`  | `PA12`       |                   |                      | `TCC2` (channel 0), `TCC0` (channel 2) |
+| `SDCARD_SCK_PIN`  | `PA13`       |                   |                      | `TCC2` (channel 1), `TCC0` (channel 3) |
+| `SDCARD_SS_PIN`   | `PA14`       |                   |                      | `TCC0` (channel 0)   |
+| `SDCARD_CD_PIN`   | `PA27`       |                   |                      |                      |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the ProductivityOpen P1AM-100](../machine/p1am-100)
+
+## Installing BOSSA
+
+In order to flash your TinyGo programs onto the ProductivityOpen P1AM-100 board, you will need to install the "bossac" command line utility which is part of the [BOSSA command line utilities](https://github.com/shumatech/BOSSA).
+
+### macOS
+
+You can use Homebrew to install the BOSSA command line interface by using the following command:
+
+```shell
+brew install bossa
+```
+
+Or if you  prefer, you can also download the installer from https://github.com/shumatech/BOSSA/releases/download/1.9.1/bossa-1.9.1.dmg
+
+Once you have downloaded it, double click on the .dmg file to perform the installation.
+
+### Linux
+
+On Linux, install from source:
+
+```shell
+sudo apt install libreadline-dev libwxgtk3.0-gtk3-dev
+git clone https://github.com/shumatech/BOSSA.git
+cd BOSSA
+make
+sudo cp bin/bossac /usr/local/bin
+```
+
+### Windows
+
+You can download BOSSA from https://github.com/shumatech/BOSSA/releases/download/1.9.1/bossa-x64-1.9.1.msi
+
+*VERY IMPORTANT*: During the installation, you must choose to install into `c:\Program Files`. The installer might have the wrong path, so edit it to match  `c:\Program Files`.
+
+After the installation, you must add BOSSA to your PATH:
+
+```shell
+set PATH=%PATH%;"c:\Program Files\BOSSA";
+```
+
+Test that you have installed "BOSSA" correctly by running this command:
+
+```shell
+bossac --help
+```
+
+## Flashing
+
+Once you have installed the needed BOSSA command line utility, as in the previous section, you are ready to build and flash code to your ProductivityOpen P1AM-100 board.
+
+### CLI Flashing
+
+- Plug your ProductivityOpen P1AM-100 board into your computer's USB port.
+- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the ProductivityOpen P1AM-100 with the blinky1 example:
+
+    ```shell
+    tinygo flash -target=p1am-100 examples/blinky1
+    ```
+
+- The ProductivityOpen P1AM-100 board should restart and then begin running your program.
+
+### Troubleshooting
+
+If you have troubles getting your ProductivityOpen P1AM-100 board to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the ProductivityOpen P1AM-100 board ready to receive code.
+- Now try running the `tinygo flash` command as above:
+
+    ```shell
+    tinygo flash -target=p1am-100 [PATH TO YOUR PROGRAM]
+    ```
+
+Once you have updated your ProductivityOpen P1AM-100 board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You can use the USB port to the ProductivityOpen P1AM-100 as a serial port. `UART0` refers to this connection.
+
+For information on how to use the built-in NINA-W102 wireless chip with the default firmware, please see the "wifinina" driver in the TinyGo drivers repository located at [https://github.com/tinygo-org/drivers/tree/release/wifinina](https://github.com/tinygo-org/drivers/tree/release/wifinina).
+
+You can also use the Espressif ESP-AT firmware, although you will need to flash it yourself. Please see the "espat" driver in the TinyGo drivers repository located at [https://github.com/tinygo-org/drivers/tree/release/espat](https://github.com/tinygo-org/drivers/tree/release/espat).
diff --git a/content/docs/reference/microcontrollers/particle-argon.md b/content/docs/reference/microcontrollers/particle-argon.md
new file mode 100644
index 00000000..20154763
--- /dev/null
+++ b/content/docs/reference/microcontrollers/particle-argon.md
@@ -0,0 +1,86 @@
+---
+title: "Particle Argon"
+weight: 3
+---
+
+[The Particle Argon](https://docs.particle.io/datasheets/wi-fi/argon-datasheet/) is a powerful Wi-Fi enabled development board. It is based on the Nordic [nRF52840](https://www.nordicsemi.com/eng/Products/nRF52840) and ESP32 2.4 GHz Wi-Fi coprocessor.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+| Bluetooth | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `A0`              | `P0_03`      |                   |
+| `A1`              | `P0_04`      |                   |
+| `A2`              | `P0_28`      |                   |
+| `A3`              | `P0_29`      |                   |
+| `A4`              | `P0_30`      |                   |
+| `A5`              | `P0_31`      |                   |
+| `D0`              | `P0_26`      | `SDA_PIN`         |
+| `D1`              | `P0_27`      | `SCL_PIN`         |
+| `D2`              | `P1_01`      |                   |
+| `D3`              | `P1_02`      |                   |
+| `D4`              | `P1_08`      |                   |
+| `D5`              | `P1_10`      |                   |
+| `D6`              | `P1_11`      |                   |
+| `D7`              | `P1_12`      | `LED`             |
+| `D8`              | `P1_03`      |                   |
+| `D9`              | `P0_06`      | `UART_TX_PIN`     |
+| `D10`             | `P0_08`      | `UART_RX_PIN`     |
+| `D11`             | `P1_14`      | `SPI0_SDI_PIN`    |
+| `D12`             | `P1_13`      | `SPI0_SDO_PIN`    |
+| `D13`             | `P1_15`      | `SPI0_SCK_PIN`    |
+| `LED_GREEN`       | `P0_14`      |                   |
+| `LED_RED`         | `P0_13`      |                   |
+| `LED_BLUE`        | `P0_15`      |                   |
+| `SPI1_SCK_PIN`    | `P0_19`      |                   |
+| `SPI1_SDO_PIN`    | `P0_20`      |                   |
+| `SPI1_SDI_PIN`    | `P0_21`      |                   |
+| `SPI1_CS_PIN`     | `P0_17`      |                   |
+| `SPI1_WP_PIN`     | `P0_22`      |                   |
+| `SPI1_HOLD_PIN`   | `P0_23`      |                   |
+| `ESP32_TXD_PIN`   | `P1_04`      |                   |
+| `ESP32_RXD_PIN`   | `P1_05`      |                   |
+| `ESP32_CTS_PIN`   | `P1_07`      |                   |
+| `ESP32_RTS_PIN`   | `P1_06`      |                   |
+| `ESP32_BOOT_MODE_PIN` | `P0_16`      |                   |
+| `ESP32_WIFI_EN_PIN` | `P0_24`      |                   |
+| `ESP32_HOST_WK_PIN` | `P0_07`      |                   |
+| `MODE_BUTTON_PIN` | `P0_11`      |                   |
+| `CHARGE_STATUS_PIN` | `P1_09`      |                   |
+| `LIPO_VOLTAGE_PIN` | `P0_05`      |                   |
+| `PCB_ANTENNA_PIN` | `P0_02`      |                   |
+| `EXTERNAL_UFL_PIN` | `P0_25`      |                   |
+| `NFC1_PIN`        | `P0_09`      |                   |
+| `NFC2_PIN`        | `P0_10`      |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Particle Argon](../machine/particle-argon)
+
+## Flashing
+
+### OpenOCD
+
+Programs are loaded onto the Particle Argon board using the `openocd` command line utility program. You must install [OpenOCD](http://openocd.org/) before you will be able to flash the Particle Argon board with your TinyGo code.
+
+- Plug your [Particle Debugger](https://store.particle.io/collections/accessories/products/particle-debugger) to Argon's debugging connector
+- Build and flash your TinyGo program using `tinygo flash -target=particle-argon`
+
+## Notes
+
+You can use the USB port to the Particle Argon as a serial port. `UART0` refers to this connection.
+
+Bluetooth support is in development but not yet completed.
diff --git a/content/docs/reference/microcontrollers/particle-boron.md b/content/docs/reference/microcontrollers/particle-boron.md
new file mode 100644
index 00000000..8457a6f3
--- /dev/null
+++ b/content/docs/reference/microcontrollers/particle-boron.md
@@ -0,0 +1,87 @@
+---
+title: "Particle Boron"
+weight: 3
+---
+
+[The Particle Boron](https://docs.particle.io/datasheets/cellular/boron-datasheet/) The Boron is a powerful LTE CAT-M1/2G/3G enabled development kit that supports cellular networks and Bluetooth LE (BLE). It is based on the Nordic [nRF52840](https://www.nordicsemi.com/eng/Products/nRF52840) and u-blox SARA coprocessor.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+| Bluetooth | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `A0`              | `P0_03`      |                   |
+| `A1`              | `P0_04`      |                   |
+| `A2`              | `P0_28`      |                   |
+| `A3`              | `P0_29`      |                   |
+| `A4`              | `P0_30`      |                   |
+| `A5`              | `P0_31`      |                   |
+| `D0`              | `P0_26`      | `SDA_PIN`         |
+| `D1`              | `P0_27`      | `SCL_PIN`         |
+| `D2`              | `P1_01`      |                   |
+| `D3`              | `P1_02`      |                   |
+| `D4`              | `P1_08`      |                   |
+| `D5`              | `P1_10`      |                   |
+| `D6`              | `P1_11`      |                   |
+| `D7`              | `P1_12`      | `LED`             |
+| `D8`              | `P1_03`      |                   |
+| `D9`              | `P0_06`      | `UART_TX_PIN`     |
+| `D10`             | `P0_08`      | `UART_RX_PIN`     |
+| `D11`             | `P1_14`      | `SPI0_SDI_PIN`    |
+| `D12`             | `P1_13`      | `SPI0_SDO_PIN`    |
+| `D13`             | `P1_15`      | `SPI0_SCK_PIN`    |
+| `LED_GREEN`       | `P0_14`      |                   |
+| `LED_RED`         | `P0_13`      |                   |
+| `LED_BLUE`        | `P0_15`      |                   |
+| `SDA1_PIN`        | `P0_24`      |                   |
+| `SCL1_PIN`        | `P1_09`      |                   |
+| `INT1_PIN`        | `P0_05`      |                   |
+| `SPI1_SCK_PIN`    | `P0_19`      |                   |
+| `SPI1_SDO_PIN`    | `P0_20`      |                   |
+| `SPI1_SDI_PIN`    | `P0_21`      |                   |
+| `SPI1_CS_PIN`     | `P0_17`      |                   |
+| `SPI1_WP_PIN`     | `P0_22`      |                   |
+| `SPI1_HOLD_PIN`   | `P0_23`      |                   |
+| `SARA_TXD_PIN`    | `P1_05`      |                   |
+| `SARA_RXD_PIN`    | `P1_04`      |                   |
+| `SARA_CTS_PIN`    | `P1_06`      |                   |
+| `SARA_RTS_PIN`    | `P1_07`      |                   |
+| `SARA_RESET_PIN`  | `P0_12`      |                   |
+| `SARA_POWER_ON_PIN` | `P0_16`      |                   |
+| `SARA_BUFF_EN_PIN` | `P0_25`      |                   |
+| `SARA_VINT_PIN`   | `P0_02`      |                   |
+| `MODE_BUTTON_PIN` | `P0_11`      |                   |
+| `ANTENNA_SEL_PIN` | `P0_07`      |                   |
+| `NFC1_PIN`        | `P0_09`      |                   |
+| `NFC2_PIN`        | `P0_10`      |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Particle Boron](../machine/particle-boron)
+
+## Flashing
+
+### OpenOCD
+
+Programs are loaded onto the Particle Boron board using the `openocd` command line utility program. You must install [OpenOCD](http://openocd.org/) before you will be able to flash the Particle Boron board with your TinyGo code.
+
+- Plug your [Particle Debugger](https://store.particle.io/collections/accessories/products/particle-debugger) to Boron's debugging connector
+- Build and flash your TinyGo program using `tinygo flash -target=particle-boron`
+
+## Notes
+
+You can use the USB port to the Particle Boron as a serial port. `UART0` refers to this connection.
+
+Bluetooth support is in development but not yet completed.
diff --git a/content/docs/reference/microcontrollers/particle-xenon.md b/content/docs/reference/microcontrollers/particle-xenon.md
new file mode 100644
index 00000000..c7b0b1c3
--- /dev/null
+++ b/content/docs/reference/microcontrollers/particle-xenon.md
@@ -0,0 +1,79 @@
+---
+title: "Particle Xenon"
+weight: 3
+---
+
+[The Particle Xenon](https://docs.particle.io/datasheets/discontinued/xenon-datasheet/) is a low cost mesh-enabled development board.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+| Bluetooth | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `A0`              | `P0_03`      |                   |
+| `A1`              | `P0_04`      |                   |
+| `A2`              | `P0_28`      |                   |
+| `A3`              | `P0_29`      |                   |
+| `A4`              | `P0_30`      |                   |
+| `A5`              | `P0_31`      |                   |
+| `D0`              | `P0_26`      | `SDA_PIN`         |
+| `D1`              | `P0_27`      | `SCL_PIN`         |
+| `D2`              | `P1_01`      |                   |
+| `D3`              | `P1_02`      |                   |
+| `D4`              | `P1_08`      |                   |
+| `D5`              | `P1_10`      |                   |
+| `D6`              | `P1_11`      |                   |
+| `D7`              | `P1_12`      | `LED`             |
+| `D8`              | `P1_03`      |                   |
+| `D9`              | `P0_06`      | `UART_TX_PIN`     |
+| `D10`             | `P0_08`      | `UART_RX_PIN`     |
+| `D11`             | `P1_14`      | `SPI0_SDI_PIN`    |
+| `D12`             | `P1_13`      | `SPI0_SDO_PIN`    |
+| `D13`             | `P1_15`      | `SPI0_SCK_PIN`    |
+| `LED_GREEN`       | `P0_14`      |                   |
+| `LED_RED`         | `P0_13`      |                   |
+| `LED_BLUE`        | `P0_15`      |                   |
+| `SPI1_SCK_PIN`    | `P0_19`      |                   |
+| `SPI1_SDO_PIN`    | `P0_20`      |                   |
+| `SPI1_SDI_PIN`    | `P0_21`      |                   |
+| `SPI1_CS_PIN`     | `P0_17`      |                   |
+| `SPI1_WP_PIN`     | `P0_22`      |                   |
+| `SPI1_HOLD_PIN`   | `P0_23`      |                   |
+| `MODE_BUTTON_PIN` | `P0_11`      |                   |
+| `CHARGE_STATUS_PIN` | `P1_09`      |                   |
+| `LIPO_VOLTAGE_PIN` | `P0_05`      |                   |
+| `PCB_ANTENNA_PIN` | `P0_24`      |                   |
+| `EXTERNAL_UFL_PIN` | `P0_25`      |                   |
+| `NFC1_PIN`        | `P0_09`      |                   |
+| `NFC2_PIN`        | `P0_10`      |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Particle Xenon](../machine/particle-xenon)
+
+## Flashing
+
+### OpenOCD
+
+Programs are loaded onto the Particle Xenon board using the `openocd` command line utility program. You must install [OpenOCD](http://openocd.org/) before you will be able to flash the Particle Xenon board with your TinyGo code.
+
+- Plug your [Particle Debugger](https://store.particle.io/collections/accessories/products/particle-debugger) to Xenon's debugging connector
+- Build and flash your TinyGo program using `tinygo flash -target=particle-xenon`
+
+## Notes
+
+You can use the USB port to the Particle Xenon as a serial port. `UART0` refers to this connection.
+
+Bluetooth support is in development but not yet completed.
diff --git a/content/docs/reference/microcontrollers/pca10031.md b/content/docs/reference/microcontrollers/pca10031.md
new file mode 100644
index 00000000..4456da72
--- /dev/null
+++ b/content/docs/reference/microcontrollers/pca10031.md
@@ -0,0 +1,60 @@
+---
+title: "Nordic Semiconductor PCA10031"
+weight: 3
+---
+
+The [Nordic Semiconductor PCA10031](https://www.nordicsemi.com/eng/Products/nRF51-Dongle) is a low-cost, versatile USB development dongle for wireless applications based on the Nordic Semiconductor [nRF51422](https://www.nordicsemi.com/eng/Products/ANT/nRF51422) chip using the nRF51 series SoC.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | Not yet |
+| USBDevice | NO  | NO  |
+| Bluetooth | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `LED1`            | `P0_21`      | `LED_RED`, `LED`  |
+| `LED2`            | `P0_22`      | `LED_GREEN`       |
+| `LED3`            | `P0_23`      | `LED_BLUE`        |
+| `UART_TX_PIN`     | `P0_09`      |                   |
+| `UART_RX_PIN`     | `P0_11`      |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the PCA10031](../machine/pca10031)
+
+## Flashing
+
+There are two options to flash the PCA10031 board.
+
+### OpenOCD (Recommended)
+
+You must install [OpenOCD](http://openocd.org/) before you will be able to flash the PCA10031 board with your TinyGo code.
+You should check [OpenOCD Documentation](http://openocd.org/Documentation) for installation and configuration instructions.
+
+Once you have installed it correctly, you will be able to flash the PCA10031 board with your TinyGo code.
+
+- Plug your PCA10031 into your computer's USB port.
+- Build and flash your TinyGo program using `tinygo flash -target=pca10031`
+
+### nrfjprog/J-Link
+
+Programs can be loaded onto the PCA10031 board using the `nrfjprog` command line utility program.
+
+First install the J-Link Software and Documentation Pack from Segger: [https://www.segger.com/downloads/jlink/#J-LinkSoftwareAndDocumentationPack](https://www.segger.com/downloads/jlink/#J-LinkSoftwareAndDocumentationPack)
+
+Then install the nRF5x Command-Line Tools: [https://docs.zephyrproject.org/latest/guides/tools/nordic_segger.html#nrf5x-command-line-tools-installation](https://docs.zephyrproject.org/latest/guides/tools/nordic_segger.html#nrf5x-command-line-tools-installation)
+
+Once you have installed both of these correctly, you will be able to flash the PCA10031 board with your TinyGo code.
+
+- Plug your PCA10031 into your computer's USB port.
+- Build and flash your TinyGo program using `tinygo flash -target=pca10031 -programmer command`
diff --git a/content/docs/reference/microcontrollers/pca10040.md b/content/docs/reference/microcontrollers/pca10040.md
new file mode 100644
index 00000000..4e677279
--- /dev/null
+++ b/content/docs/reference/microcontrollers/pca10040.md
@@ -0,0 +1,76 @@
+---
+title: "Nordic Semiconductor PCA10040"
+weight: 3
+---
+
+The [Nordic Semiconductor PCA10040](https://www.nordicsemi.com/eng/Products/Bluetooth-low-energy/nRF52-DK) is a single-board development kit for wireless applications based on the Nordic Semiconductor [nRF52832](https://www.nordicsemi.com/eng/Products/Bluetooth-low-energy/nRF52832) SoC.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | NO  | NO  |
+| Bluetooth | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `LED1`            | `P0_17`      | `LED`             |
+| `LED2`            | `P0_18`      |                   |
+| `LED3`            | `P0_19`      |                   |
+| `LED4`            | `P0_20`      |                   |
+| `BUTTON1`         | `P0_13`      | `BUTTON`          |
+| `BUTTON2`         | `P0_14`      |                   |
+| `BUTTON3`         | `P0_15`      |                   |
+| `BUTTON4`         | `P0_16`      |                   |
+| `UART_TX_PIN`     | `P0_06`      |                   |
+| `UART_RX_PIN`     | `P0_08`      |                   |
+| `ADC0`            | `P0_03`      |                   |
+| `ADC1`            | `P0_04`      |                   |
+| `ADC2`            | `P0_28`      |                   |
+| `ADC3`            | `P0_29`      |                   |
+| `ADC4`            | `P0_30`      |                   |
+| `ADC5`            | `P0_31`      |                   |
+| `SDA_PIN`         | `P0_26`      |                   |
+| `SCL_PIN`         | `P0_27`      |                   |
+| `SPI0_SCK_PIN`    | `P0_25`      |                   |
+| `SPI0_SDO_PIN`    | `P0_23`      |                   |
+| `SPI0_SDI_PIN`    | `P0_24`      |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the PCA10040](../machine/pca10040)
+
+## Flashing
+
+There are two options to flash the PCA10040 board.
+
+### OpenOCD (Recommended)
+
+You must install [OpenOCD](http://openocd.org/) before you will be able to flash the PCA10040 board with your TinyGo code.
+You should check [OpenOCD Documentation](http://openocd.org/Documentation) for installation and configuration instructions.
+
+Once you have installed it correctly, you will be able to flash the PCA10040 board with your TinyGo code.
+
+- Plug your PCA10040 into your computer's USB port.
+- Build and flash your TinyGo program using `tinygo flash -target=pca10040`
+
+### nrfjprog/J-Link
+
+Programs can be loaded onto the PCA10040 board using the `nrfjprog` command line utility program.
+
+First install the J-Link Software and Documentation Pack from Segger: [https://www.segger.com/downloads/jlink/#J-LinkSoftwareAndDocumentationPack](https://www.segger.com/downloads/jlink/#J-LinkSoftwareAndDocumentationPack)
+
+Then install the nRF5x Command-Line Tools: [https://docs.zephyrproject.org/latest/guides/tools/nordic_segger.html#nrf5x-command-line-tools-installation](https://docs.zephyrproject.org/latest/guides/tools/nordic_segger.html#nrf5x-command-line-tools-installation)
+
+Once you have installed both of these correctly, you will be able to flash the PCA10040 board with your TinyGo code.
+
+- Plug your PCA10040 into your computer's USB port.
+- Build and flash your TinyGo program using `tinygo flash -target=pca10040 -programmer command`
diff --git a/content/docs/reference/microcontrollers/pca10056.md b/content/docs/reference/microcontrollers/pca10056.md
new file mode 100644
index 00000000..4c800204
--- /dev/null
+++ b/content/docs/reference/microcontrollers/pca10056.md
@@ -0,0 +1,76 @@
+---
+title: "Nordic Semiconductor PCA10056"
+weight: 3
+---
+
+The [Nordic Semiconductor PCA10056](https://www.nordicsemi.com/Software-and-Tools/Development-Kits/nRF52840-DK) is a single-board development kit for wireless applications based on the Nordic Semiconductor [nRF52840](https://www.nordicsemi.com/eng/Products/nRF52840) SoC.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+| Bluetooth | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `LED1`            | `P0_13`      | `LED`             |
+| `LED2`            | `P0_14`      |                   |
+| `LED3`            | `P0_15`      |                   |
+| `LED4`            | `P0_16`      |                   |
+| `BUTTON1`         | `P0_11`      | `BUTTON`          |
+| `BUTTON2`         | `P0_12`      |                   |
+| `BUTTON3`         | `P0_24`      |                   |
+| `BUTTON4`         | `P0_25`      |                   |
+| `UART_TX_PIN`     | `P0_06`      |                   |
+| `UART_RX_PIN`     | `P0_08`      |                   |
+| `ADC0`            | `P0_03`      |                   |
+| `ADC1`            | `P0_04`      |                   |
+| `ADC2`            | `P0_28`      |                   |
+| `ADC3`            | `P0_29`      |                   |
+| `ADC4`            | `P0_30`      |                   |
+| `ADC5`            | `P0_31`      |                   |
+| `SDA_PIN`         | `P0_26`      |                   |
+| `SCL_PIN`         | `P0_27`      |                   |
+| `SPI0_SCK_PIN`    | `P1_15`      |                   |
+| `SPI0_SDO_PIN`    | `P1_13`      |                   |
+| `SPI0_SDI_PIN`    | `P1_14`      |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the PCA10056](../machine/pca10056)
+
+## Flashing
+
+There are two options to flash the PCA10056 board.
+
+### OpenOCD (Recommended)
+
+You must install [OpenOCD](http://openocd.org/) before you will be able to flash the PCA10056 board with your TinyGo code.
+You should check [OpenOCD Documentation](http://openocd.org/Documentation) for installation and configuration instructions.
+
+Once you have installed it correctly, you will be able to flash the PCA10056 board with your TinyGo code.
+
+- Plug your PCA10056 into your computer's USB port.
+- Build and flash your TinyGo program using `tinygo flash -target=pca10056`
+
+### nrfjprog/J-Link
+
+Programs can be loaded onto the PCA10056 board using the `nrfjprog` command line utility program.
+
+First install the J-Link Software and Documentation Pack from Segger: [https://www.segger.com/downloads/jlink/#J-LinkSoftwareAndDocumentationPack](https://www.segger.com/downloads/jlink/#J-LinkSoftwareAndDocumentationPack)
+
+Then install the nRF5x Command-Line Tools: [https://docs.zephyrproject.org/latest/guides/tools/nordic_segger.html#nrf5x-command-line-tools-installation](https://docs.zephyrproject.org/latest/guides/tools/nordic_segger.html#nrf5x-command-line-tools-installation)
+
+Once you have installed both of these correctly, you will be able to flash the PCA10056 board with your TinyGo code.
+
+- Plug your PCA10056 into your computer's USB port.
+- Build and flash your TinyGo program using `tinygo flash -target=pca10056 -programmer command`
diff --git a/content/docs/reference/microcontrollers/pca10059.md b/content/docs/reference/microcontrollers/pca10059.md
new file mode 100644
index 00000000..ad59acd5
--- /dev/null
+++ b/content/docs/reference/microcontrollers/pca10059.md
@@ -0,0 +1,53 @@
+---
+title: "Nordic Semiconductor PCA10059"
+weight: 3
+---
+
+The [Nordic Semiconductor PCA10059](https://www.nordicsemi.com/Software-and-tools/Development-Kits/nRF52840-Dongle) is a single-board development kit for wireless applications based on the Nordic Semiconductor [nRF52840](https://www.nordicsemi.com/eng/Products/nRF52840) SoC.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+| Bluetooth | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `LED1`            | `P0_06`      | `LED`             |
+| `LED2`            | `P0_08`      |                   |
+| `LED3`            | `P1_09`      |                   |
+| `LED4`            | `P0_12`      |                   |
+| `BUTTON1`         | `P1_06`      | `BUTTON`          |
+| `ADC1`            | `P0_02`      |                   |
+| `ADC2`            | `P0_04`      |                   |
+| `ADC3`            | `P0_29`      |                   |
+| `ADC4`            | `P0_31`      |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the PCA10059](../machine/pca10059)
+
+## Flashing
+
+There are two options to flash the PCA10059 board.
+
+### nrfutil
+
+Programs can be loaded onto the PCA10059 board using the `nrfutil` command line utility program.
+
+Install the nrfutil Command-Line Tools: [NordicSemiconductor/pc-nrfutil](https://github.com/NordicSemiconductor/pc-nrfutil)
+
+Once you have installed nrfutil correctly, you will be able to flash the PCA10059 board with your TinyGo code.
+
+- Plug your PCA10059 into your computer's USB port.
+- Press SW2 to go to bootloader.
+- Build and flash your TinyGo program using `tinygo flash -target=pca10059 [PATH TO YOUR PROGRAM]`
diff --git a/content/docs/reference/microcontrollers/pico-w.md b/content/docs/reference/microcontrollers/pico-w.md
new file mode 100644
index 00000000..12d93226
--- /dev/null
+++ b/content/docs/reference/microcontrollers/pico-w.md
@@ -0,0 +1,89 @@
+---
+title: "Raspberry Pi Pico W"
+weight: 3
+---
+
+The [Raspberry Pi Pico-W](https://www.raspberrypi.org/products/raspberry-pi-pico/) is a tiny development board based on the Raspberry Pi [RP2040](https://datasheets.raspberrypi.org/rp2040/rp2040-datasheet.pdf) microcontroller that also includes an onboard [Infineon CYW43439](https://www.infineon.com/cms/en/product/wireless-connectivity/airoc-wi-fi-plus-bluetooth-combos/wi-fi-4-802.11n/cyw43439/) wireless chip.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `GP0`             | `GPIO0`      | `UART0_TX_PIN`, `UART_TX_PIN` | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `GP1`             | `GPIO1`      | `UART0_RX_PIN`, `UART_RX_PIN` | `I2C0` (SCL)         | `PWM0` (channel B)   |
+| `GP2`             | `GPIO2`      | `I2C1_SDA_PIN`    | `I2C1` (SDA)         | `PWM1` (channel A)   |
+| `GP3`             | `GPIO3`      | `I2C1_SCL_PIN`    | `I2C1` (SCL)         | `PWM1` (channel B)   |
+| `GP4`             | `GPIO4`      | `I2C0_SDA_PIN`    | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `GP5`             | `GPIO5`      | `I2C0_SCL_PIN`    | `I2C0` (SCL)         | `PWM2` (channel B)   |
+| `GP6`             | `GPIO6`      |                   | `I2C1` (SDA)         | `PWM3` (channel A)   |
+| `GP7`             | `GPIO7`      |                   | `I2C1` (SCL)         | `PWM3` (channel B)   |
+| `GP8`             | `GPIO8`      | `UART1_TX_PIN`    | `I2C0` (SDA)         | `PWM4` (channel A)   |
+| `GP9`             | `GPIO9`      | `UART1_RX_PIN`    | `I2C0` (SCL)         | `PWM4` (channel B)   |
+| `GP10`            | `GPIO10`     | `SPI1_SCK_PIN`    | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `GP11`            | `GPIO11`     | `SPI1_SDO_PIN`    | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `GP12`            | `GPIO12`     | `SPI1_SDI_PIN`    | `I2C0` (SDA)         | `PWM6` (channel A)   |
+| `GP13`            | `GPIO13`     |                   | `I2C0` (SCL)         | `PWM6` (channel B)   |
+| `GP14`            | `GPIO14`     |                   | `I2C1` (SDA)         | `PWM7` (channel A)   |
+| `GP15`            | `GPIO15`     |                   | `I2C1` (SCL)         | `PWM7` (channel B)   |
+| `GP16`            | `GPIO16`     | `SPI0_SDI_PIN`    | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `GP17`            | `GPIO17`     |                   | `I2C0` (SCL)         | `PWM0` (channel B)   |
+| `GP18`            | `GPIO18`     | `SPI0_SCK_PIN`    | `I2C1` (SDA)         | `PWM1` (channel A)   |
+| `GP19`            | `GPIO19`     | `SPI0_SDO_PIN`    | `I2C1` (SCL)         | `PWM1` (channel B)   |
+| `GP20`            | `GPIO20`     |                   | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `GP21`            | `GPIO21`     |                   | `I2C0` (SCL)         | `PWM2` (channel B)   |
+| `GP22`            | `GPIO22`     |                   |                      | `PWM3` (channel A)   |
+| `GP26`            | `GPIO26`     | `ADC0`            | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `GP27`            | `GPIO27`     | `ADC1`            | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `GP28`            | `GPIO28`     | `ADC2`            |                      | `PWM6` (channel A)   |
+| `LED`             | `GPIO25`     |                   |                      | `PWM4` (channel B)   |
+| `ADC3`            | `GPIO29`     |                   |                      | `PWM6` (channel B)   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Pico](../machine/pico)
+
+## Flashing
+
+### UF2
+
+The Pico comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=pico [PATH TO YOUR PROGRAM]
+    ```
+
+- The Pico board should restart and then begin running your program.
+
+### Troubleshooting
+
+Any troubleshooting tips go here.
+
+## Notes
+
+You can use the USB port to the Pico-W as a serial port.
+
+TinyGo has support for the RP2040's on-board Programmable Input/Output (PIO) block.
+
+For more informantion, see [https://github.com/tinygo-org/pio](https://github.com/tinygo-org/pio)
+
+You can use the onboard wireless chip using the TinyGo Bluetooth package.
+
+For more informantion, see [https://github.com/tinygo-org/bluetooth](https://github.com/tinygo-org/bluetooth)
+
+You can refer to [getting started with Raspberry Pi Pico](https://datasheets.raspberrypi.org/pico/getting-started-with-pico.pdf) documentation on how to connect two Picos together (see Appendix A: Using Picoprobe) to debug and convert `UART0` output on target pico to USB output on picoprobe. You will need the [Picoprobe UF2](https://www.raspberrypi.org/documentation/rp2040/getting-started/#board-specifications), available on the Pico's website under "About" tab.
diff --git a/content/docs/reference/microcontrollers/pico.md b/content/docs/reference/microcontrollers/pico.md
new file mode 100644
index 00000000..809dab2f
--- /dev/null
+++ b/content/docs/reference/microcontrollers/pico.md
@@ -0,0 +1,85 @@
+---
+title: "Raspberry Pi Pico"
+weight: 3
+---
+
+The [Raspberry Pi Pico](https://www.raspberrypi.org/products/raspberry-pi-pico/) is a tiny development board based on the Raspberry Pi [RP2040](https://datasheets.raspberrypi.org/rp2040/rp2040-datasheet.pdf) microcontroller.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `GP0`             | `GPIO0`      | `UART0_TX_PIN`, `UART_TX_PIN` | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `GP1`             | `GPIO1`      | `UART0_RX_PIN`, `UART_RX_PIN` | `I2C0` (SCL)         | `PWM0` (channel B)   |
+| `GP2`             | `GPIO2`      | `I2C1_SDA_PIN`    | `I2C1` (SDA)         | `PWM1` (channel A)   |
+| `GP3`             | `GPIO3`      | `I2C1_SCL_PIN`    | `I2C1` (SCL)         | `PWM1` (channel B)   |
+| `GP4`             | `GPIO4`      | `I2C0_SDA_PIN`    | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `GP5`             | `GPIO5`      | `I2C0_SCL_PIN`    | `I2C0` (SCL)         | `PWM2` (channel B)   |
+| `GP6`             | `GPIO6`      |                   | `I2C1` (SDA)         | `PWM3` (channel A)   |
+| `GP7`             | `GPIO7`      |                   | `I2C1` (SCL)         | `PWM3` (channel B)   |
+| `GP8`             | `GPIO8`      | `UART1_TX_PIN`    | `I2C0` (SDA)         | `PWM4` (channel A)   |
+| `GP9`             | `GPIO9`      | `UART1_RX_PIN`    | `I2C0` (SCL)         | `PWM4` (channel B)   |
+| `GP10`            | `GPIO10`     | `SPI1_SCK_PIN`    | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `GP11`            | `GPIO11`     | `SPI1_SDO_PIN`    | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `GP12`            | `GPIO12`     | `SPI1_SDI_PIN`    | `I2C0` (SDA)         | `PWM6` (channel A)   |
+| `GP13`            | `GPIO13`     |                   | `I2C0` (SCL)         | `PWM6` (channel B)   |
+| `GP14`            | `GPIO14`     |                   | `I2C1` (SDA)         | `PWM7` (channel A)   |
+| `GP15`            | `GPIO15`     |                   | `I2C1` (SCL)         | `PWM7` (channel B)   |
+| `GP16`            | `GPIO16`     | `SPI0_SDI_PIN`    | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `GP17`            | `GPIO17`     |                   | `I2C0` (SCL)         | `PWM0` (channel B)   |
+| `GP18`            | `GPIO18`     | `SPI0_SCK_PIN`    | `I2C1` (SDA)         | `PWM1` (channel A)   |
+| `GP19`            | `GPIO19`     | `SPI0_SDO_PIN`    | `I2C1` (SCL)         | `PWM1` (channel B)   |
+| `GP20`            | `GPIO20`     |                   | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `GP21`            | `GPIO21`     |                   | `I2C0` (SCL)         | `PWM2` (channel B)   |
+| `GP22`            | `GPIO22`     |                   |                      | `PWM3` (channel A)   |
+| `GP26`            | `GPIO26`     | `ADC0`            | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `GP27`            | `GPIO27`     | `ADC1`            | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `GP28`            | `GPIO28`     | `ADC2`            |                      | `PWM6` (channel A)   |
+| `LED`             | `GPIO25`     |                   |                      | `PWM4` (channel B)   |
+| `ADC3`            | `GPIO29`     |                   |                      | `PWM6` (channel B)   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Pico](../machine/pico)
+
+## Flashing
+
+### UF2
+
+The Pico comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=pico [PATH TO YOUR PROGRAM]
+    ```
+
+- The Pico board should restart and then begin running your program.
+
+### Troubleshooting
+
+Any troubleshooting tips go here.
+
+## Notes
+
+You can use the USB port to the Pico as a serial port.
+
+TinyGo has support for the RP2040's on-board Programmable Input/Output (PIO) block.
+
+For more informantion, see [https://github.com/tinygo-org/pio](https://github.com/tinygo-org/pio)
+
+You can refer to [getting started with Raspberry Pi Pico](https://datasheets.raspberrypi.org/pico/getting-started-with-pico.pdf) documentation on how to connect two Picos together (see Appendix A: Using Picoprobe) to debug and convert `UART0` output on target pico to USB output on picoprobe. You will need the [Picoprobe UF2](https://www.raspberrypi.org/documentation/rp2040/getting-started/#board-specifications), available on the Pico's website under "About" tab.
diff --git a/content/docs/reference/microcontrollers/pico2-w.md b/content/docs/reference/microcontrollers/pico2-w.md
new file mode 100644
index 00000000..2d2370c0
--- /dev/null
+++ b/content/docs/reference/microcontrollers/pico2-w.md
@@ -0,0 +1,87 @@
+---
+title: "Raspberry Pi Pico 2 W"
+weight: 3
+---
+
+The [Raspberry Pi Pico 2 - W](https://www.raspberrypi.com/products/raspberry-pi-pico-2/) is a tiny development board based on the Raspberry Pi [RP2350](https://datasheets.raspberrypi.org/rp2350/rp2350-datasheet.pdf) microcontroller. It also includes an onboard [Infineon CYW43439](https://www.infineon.com/cms/en/product/wireless-connectivity/airoc-wi-fi-plus-bluetooth-combos/wi-fi-4-802.11n/cyw43439/) wireless chip.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `GP0`             | `GPIO0`      | `UART0_TX_PIN`, `UART_TX_PIN` | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `GP1`             | `GPIO1`      | `UART0_RX_PIN`, `UART_RX_PIN` | `I2C0` (SCL)         | `PWM0` (channel B)   |
+| `GP2`             | `GPIO2`      | `I2C1_SDA_PIN`    | `I2C1` (SDA)         | `PWM1` (channel A)   |
+| `GP3`             | `GPIO3`      | `I2C1_SCL_PIN`    | `I2C1` (SCL)         | `PWM1` (channel B)   |
+| `GP4`             | `GPIO4`      | `I2C0_SDA_PIN`    | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `GP5`             | `GPIO5`      | `I2C0_SCL_PIN`    | `I2C0` (SCL)         | `PWM2` (channel B)   |
+| `GP6`             | `GPIO6`      |                   | `I2C1` (SDA)         | `PWM3` (channel A)   |
+| `GP7`             | `GPIO7`      |                   | `I2C1` (SCL)         | `PWM3` (channel B)   |
+| `GP8`             | `GPIO8`      | `UART1_TX_PIN`    | `I2C0` (SDA)         | `PWM4` (channel A)   |
+| `GP9`             | `GPIO9`      | `UART1_RX_PIN`    | `I2C0` (SCL)         | `PWM4` (channel B)   |
+| `GP10`            | `GPIO10`     | `SPI1_SCK_PIN`    | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `GP11`            | `GPIO11`     | `SPI1_SDO_PIN`    | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `GP12`            | `GPIO12`     | `SPI1_SDI_PIN`    | `I2C0` (SDA)         | `PWM6` (channel A)   |
+| `GP13`            | `GPIO13`     |                   | `I2C0` (SCL)         | `PWM6` (channel B)   |
+| `GP14`            | `GPIO14`     |                   | `I2C1` (SDA)         | `PWM7` (channel A)   |
+| `GP15`            | `GPIO15`     |                   | `I2C1` (SCL)         | `PWM7` (channel B)   |
+| `GP16`            | `GPIO16`     | `SPI0_SDI_PIN`    | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `GP17`            | `GPIO17`     |                   | `I2C0` (SCL)         | `PWM0` (channel B)   |
+| `GP18`            | `GPIO18`     | `SPI0_SCK_PIN`    | `I2C1` (SDA)         | `PWM1` (channel A)   |
+| `GP19`            | `GPIO19`     | `SPI0_SDO_PIN`    | `I2C1` (SCL)         | `PWM1` (channel B)   |
+| `GP20`            | `GPIO20`     |                   | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `GP21`            | `GPIO21`     |                   | `I2C0` (SCL)         | `PWM2` (channel B)   |
+| `GP22`            | `GPIO22`     |                   |                      | `PWM3` (channel A)   |
+| `GP26`            | `GPIO26`     | `ADC0`            | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `GP27`            | `GPIO27`     | `ADC1`            | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `GP28`            | `GPIO28`     | `ADC2`            |                      | `PWM6` (channel A)   |
+| `LED`             | `GPIO25`     |                   |                      | `PWM4` (channel B)   |
+| `ADC3`            | `GPIO29`     |                   |                      | `PWM6` (channel B)   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Pico](../machine/pico)
+
+## Flashing
+
+### UF2
+
+The Pico 2 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=pico2 [PATH TO YOUR PROGRAM]
+    ```
+
+- The Pico 2 board should restart and then begin running your program.
+
+### Troubleshooting
+
+Any troubleshooting tips go here.
+
+## Notes
+
+You can use the USB port to the Pico as a serial port.
+
+TinyGo has support for the RP2350's on-board Programmable Input/Output (PIO) block.
+
+For more informantion, see [https://github.com/tinygo-org/pio](https://github.com/tinygo-org/pio)
+
+You can use the onboard wireless chip using the TinyGo Bluetooth package.
+
+For more informantion, see [https://github.com/tinygo-org/bluetooth](https://github.com/tinygo-org/bluetooth)
diff --git a/content/docs/reference/microcontrollers/pico2.md b/content/docs/reference/microcontrollers/pico2.md
new file mode 100644
index 00000000..14024a23
--- /dev/null
+++ b/content/docs/reference/microcontrollers/pico2.md
@@ -0,0 +1,83 @@
+---
+title: "Raspberry Pi Pico 2"
+weight: 3
+---
+
+The [Raspberry Pi Pico 2](https://www.raspberrypi.com/products/raspberry-pi-pico-2/) is a tiny development board based on the Raspberry Pi [RP2350](https://datasheets.raspberrypi.org/rp2350/rp2350-datasheet.pdf) microcontroller.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `GP0`             | `GPIO0`      | `UART0_TX_PIN`, `UART_TX_PIN` | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `GP1`             | `GPIO1`      | `UART0_RX_PIN`, `UART_RX_PIN` | `I2C0` (SCL)         | `PWM0` (channel B)   |
+| `GP2`             | `GPIO2`      | `I2C1_SDA_PIN`    | `I2C1` (SDA)         | `PWM1` (channel A)   |
+| `GP3`             | `GPIO3`      | `I2C1_SCL_PIN`    | `I2C1` (SCL)         | `PWM1` (channel B)   |
+| `GP4`             | `GPIO4`      | `I2C0_SDA_PIN`    | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `GP5`             | `GPIO5`      | `I2C0_SCL_PIN`    | `I2C0` (SCL)         | `PWM2` (channel B)   |
+| `GP6`             | `GPIO6`      |                   | `I2C1` (SDA)         | `PWM3` (channel A)   |
+| `GP7`             | `GPIO7`      |                   | `I2C1` (SCL)         | `PWM3` (channel B)   |
+| `GP8`             | `GPIO8`      | `UART1_TX_PIN`    | `I2C0` (SDA)         | `PWM4` (channel A)   |
+| `GP9`             | `GPIO9`      | `UART1_RX_PIN`    | `I2C0` (SCL)         | `PWM4` (channel B)   |
+| `GP10`            | `GPIO10`     | `SPI1_SCK_PIN`    | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `GP11`            | `GPIO11`     | `SPI1_SDO_PIN`    | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `GP12`            | `GPIO12`     | `SPI1_SDI_PIN`    | `I2C0` (SDA)         | `PWM6` (channel A)   |
+| `GP13`            | `GPIO13`     |                   | `I2C0` (SCL)         | `PWM6` (channel B)   |
+| `GP14`            | `GPIO14`     |                   | `I2C1` (SDA)         | `PWM7` (channel A)   |
+| `GP15`            | `GPIO15`     |                   | `I2C1` (SCL)         | `PWM7` (channel B)   |
+| `GP16`            | `GPIO16`     | `SPI0_SDI_PIN`    | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `GP17`            | `GPIO17`     |                   | `I2C0` (SCL)         | `PWM0` (channel B)   |
+| `GP18`            | `GPIO18`     | `SPI0_SCK_PIN`    | `I2C1` (SDA)         | `PWM1` (channel A)   |
+| `GP19`            | `GPIO19`     | `SPI0_SDO_PIN`    | `I2C1` (SCL)         | `PWM1` (channel B)   |
+| `GP20`            | `GPIO20`     |                   | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `GP21`            | `GPIO21`     |                   | `I2C0` (SCL)         | `PWM2` (channel B)   |
+| `GP22`            | `GPIO22`     |                   |                      | `PWM3` (channel A)   |
+| `GP26`            | `GPIO26`     | `ADC0`            | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `GP27`            | `GPIO27`     | `ADC1`            | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `GP28`            | `GPIO28`     | `ADC2`            |                      | `PWM6` (channel A)   |
+| `LED`             | `GPIO25`     |                   |                      | `PWM4` (channel B)   |
+| `ADC3`            | `GPIO29`     |                   |                      | `PWM6` (channel B)   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Pico](../machine/pico)
+
+## Flashing
+
+### UF2
+
+The Pico 2 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=pico2 [PATH TO YOUR PROGRAM]
+    ```
+
+- The Pico 2 board should restart and then begin running your program.
+
+### Troubleshooting
+
+Any troubleshooting tips go here.
+
+## Notes
+
+You can use the USB port to the Pico 2 as a serial port.
+
+TinyGo has support for the RP2350's on-board Programmable Input/Output (PIO) block.
+
+For more informantion, see [https://github.com/tinygo-org/pio](https://github.com/tinygo-org/pio)
diff --git a/content/microcontrollers/pinetime.md b/content/docs/reference/microcontrollers/pinetime-devkit0.md
similarity index 66%
rename from content/microcontrollers/pinetime.md
rename to content/docs/reference/microcontrollers/pinetime-devkit0.md
index 6ec82e99..86973fe9 100644
--- a/content/microcontrollers/pinetime.md
+++ b/content/docs/reference/microcontrollers/pinetime-devkit0.md
@@ -1,9 +1,9 @@
 ---
-title: "PineTime"
+title: "PineTime DevKit"
 weight: 3
 ---
 
-The [PineTime](https://wiki.pine64.org/index.php/PineTime) is a smartwatch by [Pine64](https://www.pine64.org/) that is based on the Nordic Semiconductor [nRF52832](https://www.nordicsemi.com/eng/Products/Bluetooth-low-energy/nRF52832) SoC. As of October 2019, a limited amount has been produced for developers.
+The [PineTime](https://wiki.pine64.org/index.php/PineTime) is a smartwatch by [Pine64](https://www.pine64.org/) that is based on the Nordic Semiconductor [nRF52832](https://www.nordicsemi.com/eng/Products/Bluetooth-low-energy/nRF52832) SoC.
 
 ## Interfaces
 
@@ -11,10 +11,31 @@ The [PineTime](https://wiki.pine64.org/index.php/PineTime) is a smartwatch by [P
 | --------- | ------------- | ----- |
 | GPIO      | YES | YES |
 | UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | NO  | NO  |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `LED1`            | `P0_23`      | `LED`, `LCD_BACKLIGHT_HIGH` |
+| `LED2`            | `P0_22`      | `LCD_BACKLIGHT_MID` |
+| `LED3`            | `P0_14`      | `LCD_BACKLIGHT_LOW` |
+| `UART_TX_PIN`     | `P0_11`      |                   |
+| `SPI0_SCK_PIN`    | `P0_02`      | `LCD_SCK`         |
+| `SPI0_SDO_PIN`    | `P0_03`      | `LCD_SDI`         |
+| `SPI0_SDI_PIN`    | `P0_04`      |                   |
+| `SDA_PIN`         | `P0_06`      |                   |
+| `SCL_PIN`         | `P0_07`      |                   |
+| `BUTTON_IN`       | `P0_13`      |                   |
+| `BUTTON_OUT`      | `P0_15`      |                   |
+| `VIBRATOR_PIN`    | `P0_16`      |                   |
+| `LCD_RS`          | `P0_18`      |                   |
+| `LCD_CS`          | `P0_25`      |                   |
+| `LCD_RESET`       | `P0_26`      |                   |
 
 ## Machine Package Docs
 
diff --git a/content/docs/reference/microcontrollers/pybadge.md b/content/docs/reference/microcontrollers/pybadge.md
new file mode 100644
index 00000000..0c249306
--- /dev/null
+++ b/content/docs/reference/microcontrollers/pybadge.md
@@ -0,0 +1,110 @@
+---
+title: "Adafruit PyBadge"
+weight: 3
+---
+
+The [Adafruit PyBadge](https://www.adafruit.com/product/4200) is a ARM development board based on the Atmel [ATSAMD51J19A](https://www.microchip.com/wwwproducts/en/ATSAMD51J19A) family of SoC.
+
+It has many built-in devices, such as a 1.8" 160x128 Color TFT Display, 8 x buttons, 5 x NeoPixels, a triple-axis accelerometer, a light sensor, and a speaker. The PyBadge uses the ST7735 display, so you may use the tinygo-org st7735 driver. The accelerometer is the LIS3DH so you may use the tinygo lis3dh driver
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `D0`              | `PB17`       | `UART_RX_PIN`, `NINA_RX` |                      | `TCC3` (channel 1), `TCC0` (channel 5) |
+| `D1`              | `PB16`       | `UART_TX_PIN`, `NINA_TX` |                      | `TCC3` (channel 0), `TCC0` (channel 4) |
+| `D2`              | `PB03`       | `A8`              |                      | `TCC2` (channel 3)   |
+| `D3`              | `PB02`       | `A9`              |                      | `TCC2` (channel 2)   |
+| `D4`              | `PA14`       |                   |                      | `TCC2` (channel 0), `TCC1` (channel 2) |
+| `D5`              | `PA16`       |                   |                      | `TCC1` (channel 0), `TCC0` (channel 4) |
+| `D6`              | `PA18`       |                   |                      | `TCC1` (channel 2), `TCC0` (channel 6) |
+| `D7`              | `PB14`       |                   |                      | `TCC4` (channel 0), `TCC0` (channel 2) |
+| `D8`              | `PA15`       | `NEOPIXELS`, `WS2812` |                      | `TCC2` (channel 1), `TCC1` (channel 3) |
+| `D9`              | `PA19`       |                   |                      | `TCC1` (channel 3), `TCC0` (channel 7) |
+| `D10`             | `PA20`       | `NINA_GPIO0`, `NINA_RTS` |                      | `TCC1` (channel 4), `TCC0` (channel 0) |
+| `D11`             | `PA21`       | `NINA_ACK`, `NINA_CTS` |                      | `TCC1` (channel 5), `TCC0` (channel 1) |
+| `D12`             | `PA22`       | `NINA_RESETN`     |                      | `TCC1` (channel 6), `TCC0` (channel 2) |
+| `D13`             | `PA23`       | `LED`, `NINA_CS`  |                      | `TCC1` (channel 7), `TCC0` (channel 3) |
+| `A0`              | `PA02`       |                   |                      |                      |
+| `A1`              | `PA05`       |                   |                      |                      |
+| `A2`              | `PB08`       |                   |                      |                      |
+| `A3`              | `PB09`       |                   |                      |                      |
+| `A4`              | `PA04`       | `UART2_TX_PIN`    |                      |                      |
+| `A5`              | `PA06`       | `UART2_RX_PIN`    |                      |                      |
+| `A6`              | `PB01`       |                   |                      |                      |
+| `A7`              | `PB04`       | `LIGHTSENSOR`     |                      |                      |
+| `BUTTON_LATCH`    | `PB00`       |                   |                      |                      |
+| `BUTTON_OUT`      | `PB30`       |                   |                      | `TCC4` (channel 0), `TCC0` (channel 6) |
+| `BUTTON_CLK`      | `PB31`       |                   |                      | `TCC4` (channel 1), `TCC0` (channel 7) |
+| `TFT_DC`          | `PB05`       |                   |                      |                      |
+| `TFT_CS`          | `PB07`       |                   |                      |                      |
+| `TFT_RST`         | `PA00`       |                   |                      |                      |
+| `TFT_LITE`        | `PA01`       |                   |                      |                      |
+| `SPEAKER_ENABLE`  | `PA27`       |                   |                      |                      |
+| `USBCDC_DM_PIN`   | `PA24`       |                   |                      | `TCC2` (channel 2)   |
+| `USBCDC_DP_PIN`   | `PA25`       |                   |                      | `TCC2` (channel 3)   |
+| `SDA_PIN`         | `PA12`       |                   | `I2C0` (SDA)         | `TCC0` (channel 6), `TCC1` (channel 2) |
+| `SCL_PIN`         | `PA13`       |                   | `I2C0` (SCL)         | `TCC0` (channel 7), `TCC1` (channel 3) |
+| `SPI0_SCK_PIN`    | `PA17`       | `NINA_SCK`        |                      | `TCC1` (channel 1), `TCC0` (channel 5) |
+| `SPI0_SDO_PIN`    | `PB23`       | `NINA_SDO`        |                      |                      |
+| `SPI0_SDI_PIN`    | `PB22`       | `NINA_SDI`        |                      |                      |
+| `SPI1_SCK_PIN`    | `PB13`       |                   |                      | `TCC3` (channel 1), `TCC0` (channel 1) |
+| `SPI1_SDO_PIN`    | `PB15`       |                   |                      | `TCC4` (channel 1), `TCC0` (channel 3) |
+| `QSPI_SCK`        | `PB10`       |                   |                      | `TCC0` (channel 4), `TCC1` (channel 0) |
+| `QSPI_CS`         | `PB11`       |                   |                      | `TCC0` (channel 5), `TCC1` (channel 1) |
+| `QSPI_DATA0`      | `PA08`       |                   | `I2C0` (SDA)         | `TCC0` (channel 0), `TCC1` (channel 4) |
+| `QSPI_DATA1`      | `PA09`       |                   | `I2C0` (SCL)         | `TCC0` (channel 1), `TCC1` (channel 5) |
+| `QSPI_DATA2`      | `PA10`       |                   |                      | `TCC0` (channel 2), `TCC1` (channel 6) |
+| `QSPI_DATA3`      | `PA11`       |                   |                      | `TCC0` (channel 3), `TCC1` (channel 7) |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Adafruit PyBadge](../machine/pybadge)
+
+## Flashing
+
+### UF2
+
+The PyBadge comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Plug your PyBadge into your computer's USB port.
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=pybadge [PATH TO YOUR PROGRAM]
+    ```
+
+- The PyBadge board should restart and then begin running your program.
+
+### Troubleshooting
+
+If you have troubles getting your PyBadge board to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the PyBadge board ready to receive code.
+- The PyBadge board will appear to your computer like a USB drive.
+- Now try running the command as above:
+
+
+```shell
+tinygo flash -target=pybadge [PATH TO YOUR PROGRAM]
+```
+
+Once you have updated your PyBadge board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You can use the USB port to the PyBadge as a serial port. `UART0` refers to this connection.
diff --git a/content/docs/reference/microcontrollers/pygamer.md b/content/docs/reference/microcontrollers/pygamer.md
new file mode 100644
index 00000000..59498e1b
--- /dev/null
+++ b/content/docs/reference/microcontrollers/pygamer.md
@@ -0,0 +1,112 @@
+---
+title: "Adafruit PyGamer"
+weight: 3
+---
+
+The [Adafruit PyGamer](https://www.adafruit.com/product/4242) is a ARM development board based on the Atmel [ATSAMD51J19A](https://www.microchip.com/wwwproducts/en/ATSAMD51J19A) family of SoC.
+
+It has many built-in devices, such as a 1.8" 160x128 Color TFT Display, a dual-potentiometer analog stick, 4 x square-top buttons, 5 x NeoPixel LED, a triple-axis accelerometer, a light sensor, and a speaker.  The PyGamer uses the ST7735 display, so you may use the tinygo-org st7735 driver. The accelerometer is the LIS3DH so you may use the tinygo lis3dh driver.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `D0`              | `PB17`       | `UART_RX_PIN`     |                      | `TCC3` (channel 1), `TCC0` (channel 5) |
+| `D1`              | `PB16`       | `UART_TX_PIN`     |                      | `TCC3` (channel 0), `TCC0` (channel 4) |
+| `D2`              | `PB03`       | `A8`              |                      | `TCC2` (channel 3)   |
+| `D3`              | `PB02`       | `A9`              |                      | `TCC2` (channel 2)   |
+| `D4`              | `PA14`       |                   |                      | `TCC2` (channel 0), `TCC1` (channel 2) |
+| `D5`              | `PA16`       |                   |                      | `TCC1` (channel 0), `TCC0` (channel 4) |
+| `D6`              | `PA18`       |                   |                      | `TCC1` (channel 2), `TCC0` (channel 6) |
+| `D7`              | `PB14`       | `SD_CS`           |                      | `TCC4` (channel 0), `TCC0` (channel 2) |
+| `D8`              | `PA15`       | `NEOPIXELS`, `WS2812` |                      | `TCC2` (channel 1), `TCC1` (channel 3) |
+| `D9`              | `PA19`       |                   |                      | `TCC1` (channel 3), `TCC0` (channel 7) |
+| `D10`             | `PA20`       |                   |                      | `TCC1` (channel 4), `TCC0` (channel 0) |
+| `D11`             | `PA21`       |                   |                      | `TCC1` (channel 5), `TCC0` (channel 1) |
+| `D12`             | `PA22`       |                   |                      | `TCC1` (channel 6), `TCC0` (channel 2) |
+| `D13`             | `PA23`       | `LED`             |                      | `TCC1` (channel 7), `TCC0` (channel 3) |
+| `A0`              | `PA02`       |                   |                      |                      |
+| `A1`              | `PA05`       |                   |                      |                      |
+| `A2`              | `PB08`       |                   |                      |                      |
+| `A3`              | `PB09`       |                   |                      |                      |
+| `A4`              | `PA04`       | `UART2_TX_PIN`    |                      |                      |
+| `A5`              | `PA06`       | `UART2_RX_PIN`    |                      |                      |
+| `A6`              | `PB01`       |                   |                      |                      |
+| `A7`              | `PB04`       | `LIGHTSENSOR`     |                      |                      |
+| `BUTTON_LATCH`    | `PB00`       |                   |                      |                      |
+| `BUTTON_OUT`      | `PB30`       |                   |                      | `TCC4` (channel 0), `TCC0` (channel 6) |
+| `BUTTON_CLK`      | `PB31`       |                   |                      | `TCC4` (channel 1), `TCC0` (channel 7) |
+| `JOYY`            | `PB06`       |                   |                      |                      |
+| `JOYX`            | `PB07`       |                   |                      |                      |
+| `TFT_DC`          | `PB05`       |                   |                      |                      |
+| `TFT_CS`          | `PB12`       |                   |                      | `TCC3` (channel 0), `TCC0` (channel 0) |
+| `TFT_RST`         | `PA00`       |                   |                      |                      |
+| `TFT_LITE`        | `PA01`       |                   |                      |                      |
+| `SPEAKER_ENABLE`  | `PA27`       |                   |                      |                      |
+| `USBCDC_DM_PIN`   | `PA24`       |                   |                      | `TCC2` (channel 2)   |
+| `USBCDC_DP_PIN`   | `PA25`       |                   |                      | `TCC2` (channel 3)   |
+| `SDA_PIN`         | `PA12`       |                   | `I2C0` (SDA)         | `TCC0` (channel 6), `TCC1` (channel 2) |
+| `SCL_PIN`         | `PA13`       |                   | `I2C0` (SCL)         | `TCC0` (channel 7), `TCC1` (channel 3) |
+| `SPI0_SCK_PIN`    | `PA17`       |                   |                      | `TCC1` (channel 1), `TCC0` (channel 5) |
+| `SPI0_SDO_PIN`    | `PB23`       |                   |                      |                      |
+| `SPI0_SDI_PIN`    | `PB22`       |                   |                      |                      |
+| `SPI1_SCK_PIN`    | `PB13`       |                   |                      | `TCC3` (channel 1), `TCC0` (channel 1) |
+| `SPI1_SDO_PIN`    | `PB15`       |                   |                      | `TCC4` (channel 1), `TCC0` (channel 3) |
+| `QSPI_SCK`        | `PB10`       |                   |                      | `TCC0` (channel 4), `TCC1` (channel 0) |
+| `QSPI_CS`         | `PB11`       |                   |                      | `TCC0` (channel 5), `TCC1` (channel 1) |
+| `QSPI_DATA0`      | `PA08`       |                   | `I2C0` (SDA)         | `TCC0` (channel 0), `TCC1` (channel 4) |
+| `QSPI_DATA1`      | `PA09`       |                   | `I2C0` (SCL)         | `TCC0` (channel 1), `TCC1` (channel 5) |
+| `QSPI_DATA2`      | `PA10`       |                   |                      | `TCC0` (channel 2), `TCC1` (channel 6) |
+| `QSPI_DATA3`      | `PA11`       |                   |                      | `TCC0` (channel 3), `TCC1` (channel 7) |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Adafruit PyGamer](../machine/pygamer)
+
+## Flashing
+
+### UF2
+
+The PyGamer comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Plug your PyGamer into your computer's USB port.
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=pygamer [PATH TO YOUR PROGRAM]
+    ```
+
+- The PyGamer board should restart and then begin running your program.
+
+### Troubleshooting
+
+If you have troubles getting your PyGamer board to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the PyGamer board ready to receive code.
+- The PyGamer board will appear to your computer like a USB drive.
+- Now try running the command as above:
+
+
+```shell
+tinygo flash -target=pygamer [PATH TO YOUR PROGRAM]
+```
+
+Once you have updated your PyGamer board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You can use the USB port to the PyGamer as a serial port. `UART0` refers to this connection.
diff --git a/content/docs/reference/microcontrollers/pyportal.md b/content/docs/reference/microcontrollers/pyportal.md
new file mode 100644
index 00000000..325366b4
--- /dev/null
+++ b/content/docs/reference/microcontrollers/pyportal.md
@@ -0,0 +1,112 @@
+---
+title: "Adafruit PyPortal"
+weight: 3
+---
+
+The [Adafruit PyPortal](https://www.adafruit.com/product/4116) is a ARM board based on the Microchip [ATSAMD51J20A](https://www.microchip.com/wwwproducts/en/ATSAMD51J20A) family of SoC.
+
+The PyPortal also has an Espressif ESP32 Wi-Fi coprocessor with TLS/SSL support built-in. PyPortal has a 3.2″ 320 x 240 color TFT with resistive touch screen. PyPortal includes: speaker, light sensor, temperature sensor, NeoPixel, microSD card slot, 8MB flash, plug-in ports for I2C and 2 analog/digital pins,
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `D0`              | `PB13`       | `NINA_RX`, `UART_RX_PIN` |                      | `TCC3` (channel 1), `TCC0` (channel 1) |
+| `D1`              | `PB12`       | `NINA_TX`, `UART_TX_PIN` |                      | `TCC3` (channel 0), `TCC0` (channel 0) |
+| `D2`              | `PB22`       | `NEOPIXEL`, `WS2812` |                      |                      |
+| `D3`              | `PA04`       | `A1`              |                      |                      |
+| `D4`              | `PA05`       | `A3`              |                      |                      |
+| `D5`              | `PB16`       | `NINA_ACK`, `NINA_CTS` |                      | `TCC3` (channel 0), `TCC0` (channel 4) |
+| `D6`              | `PB15`       | `NINA_GPIO0`, `NINA_RTS` |                      | `TCC4` (channel 1), `TCC0` (channel 3) |
+| `D7`              | `PB17`       | `NINA_RESETN`     |                      | `TCC3` (channel 1), `TCC0` (channel 5) |
+| `D8`              | `PB14`       | `NINA_CS`         |                      | `TCC4` (channel 0), `TCC0` (channel 2) |
+| `D9`              | `PB04`       | `TFT_RD`          |                      |                      |
+| `D10`             | `PB05`       | `TFT_DC`          |                      |                      |
+| `D11`             | `PB06`       | `TFT_CS`          |                      |                      |
+| `D12`             | `PB07`       | `TFT_TE`          |                      |                      |
+| `D13`             | `PB23`       | `LED`             |                      |                      |
+| `D24`             | `PA00`       | `TFT_RESET`       |                      |                      |
+| `D25`             | `PB31`       | `TFT_BACKLIGHT`   |                      | `TCC4` (channel 1), `TCC0` (channel 7) |
+| `D26`             | `PB09`       | `TFT_WR`          |                      |                      |
+| `D27`             | `PB02`       | `SDA_PIN`         |                      | `TCC2` (channel 2)   |
+| `D28`             | `PB03`       | `SCL_PIN`         |                      | `TCC2` (channel 3)   |
+| `D29`             | `PA12`       | `SPI0_SDO_PIN`, `NINA_SDO` |                      | `TCC0` (channel 6), `TCC1` (channel 2) |
+| `D30`             | `PA13`       | `SPI0_SCK_PIN`, `NINA_SCK` |                      | `TCC0` (channel 7), `TCC1` (channel 3) |
+| `D31`             | `PA14`       | `SPI0_SDI_PIN`, `NINA_SDI` |                      | `TCC2` (channel 0), `TCC1` (channel 2) |
+| `D32`             | `PB30`       |                   |                      | `TCC4` (channel 0), `TCC0` (channel 6) |
+| `D33`             | `PA01`       |                   |                      |                      |
+| `D34`             | `PA16`       | `LCD_DATA0`       |                      | `TCC1` (channel 0), `TCC0` (channel 4) |
+| `D35`             | `PA17`       |                   |                      | `TCC1` (channel 1), `TCC0` (channel 5) |
+| `D36`             | `PA18`       |                   |                      | `TCC1` (channel 2), `TCC0` (channel 6) |
+| `D37`             | `PA19`       |                   |                      | `TCC1` (channel 3), `TCC0` (channel 7) |
+| `D38`             | `PA20`       |                   |                      | `TCC1` (channel 4), `TCC0` (channel 0) |
+| `D39`             | `PA21`       |                   |                      | `TCC1` (channel 5), `TCC0` (channel 1) |
+| `D40`             | `PA22`       |                   | `I2C0` (SDA)         | `TCC1` (channel 6), `TCC0` (channel 2) |
+| `D41`             | `PA23`       |                   | `I2C0` (SCL)         | `TCC1` (channel 7), `TCC0` (channel 3) |
+| `D42`             | `PB10`       | `QSPI_SCK`        |                      | `TCC0` (channel 4), `TCC1` (channel 0) |
+| `D43`             | `PB11`       | `QSPI_CS`         |                      | `TCC0` (channel 5), `TCC1` (channel 1) |
+| `D44`             | `PA08`       | `QSPI_DATA0`      |                      | `TCC0` (channel 0), `TCC1` (channel 4) |
+| `D45`             | `PA09`       | `QSPI_DATA1`      |                      | `TCC0` (channel 1), `TCC1` (channel 5) |
+| `D46`             | `PA10`       | `QSPI_DATA2`      |                      | `TCC0` (channel 2), `TCC1` (channel 6) |
+| `D47`             | `PA11`       | `QSPI_DATA3`      |                      | `TCC0` (channel 3), `TCC1` (channel 7) |
+| `D50`             | `PA02`       | `SPK_SD`, `A0`, `AUDIO_OUT` |                      |                      |
+| `D51`             | `PA15`       |                   |                      | `TCC2` (channel 1), `TCC1` (channel 3) |
+| `A2`              | `PA07`       | `LIGHT`           |                      |                      |
+| `A4`              | `PB00`       | `TOUCH_YD`        |                      |                      |
+| `A5`              | `PB01`       | `TOUCH_XL`        |                      |                      |
+| `A6`              | `PA06`       | `TOUCH_YU`        |                      |                      |
+| `A7`              | `PB08`       | `TOUCH_XR`        |                      |                      |
+| `USBCDC_DM_PIN`   | `PA24`       |                   |                      | `TCC2` (channel 2)   |
+| `USBCDC_DP_PIN`   | `PA25`       |                   |                      | `TCC2` (channel 3)   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Adafruit PyPortal](../machine/pyportal)
+
+## Flashing
+
+### UF2
+
+The PyPortal comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Plug your PyPortal into your computer's USB port.
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=pyportal [PATH TO YOUR PROGRAM]
+    ```
+
+- The PyPortal board should restart and then begin running your program.
+
+### Troubleshooting
+
+If you have troubles getting your PyPortal board to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the PyPortal board ready to receive code.
+- The PyPortal board will appear to your computer like a USB drive.
+- Now try running the command as above:
+
+
+```shell
+tinygo flash -target=pyportal [PATH TO YOUR PROGRAM]
+```
+
+Once you have updated your PyPortal board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You can use the USB port to the PyPortal as a serial port. `UART0` refers to this connection.
diff --git a/content/docs/reference/microcontrollers/qtpy-rp2040.md b/content/docs/reference/microcontrollers/qtpy-rp2040.md
new file mode 100644
index 00000000..146cd028
--- /dev/null
+++ b/content/docs/reference/microcontrollers/qtpy-rp2040.md
@@ -0,0 +1,80 @@
+---
+title: "Adafruit QT Py RP2040"
+weight: 3
+---
+
+The [Adafruit QT Py RP2040](https://www.adafruit.com/product/4900) is a tiny development board based on the Raspberry Pi [RP2040](https://datasheets.raspberrypi.org/rp2040/rp2040-datasheet.pdf) microcontroller.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `SDA`             | `GPIO24`     | `I2C0_SDA_PIN`, `SDA_PIN`, `SPI1_SDI_PIN` |                      | `PWM4` (channel A)   |
+| `SCL`             | `GPIO25`     | `I2C0_SCL_PIN`, `SCL_PIN`, `SPI1_CS` |                      | `PWM4` (channel B)   |
+| `TX`              | `GPIO20`     | `UART1_TX_PIN`    | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `MO`              | `GPIO3`      | `MOSI`, `SPI0_SDO_PIN` | `I2C1` (SCL)         | `PWM1` (channel B)   |
+| `MI`              | `GPIO4`      | `MISO`, `SPI0_SDI_PIN` | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `SCK`             | `GPIO6`      | `SPI0_SCK_PIN`    | `I2C1` (SDA)         | `PWM3` (channel A)   |
+| `RX`              | `GPIO5`      | `SPI0_CS`, `UART1_RX_PIN` | `I2C0` (SCL)         | `PWM2` (channel B)   |
+| `QT_SCL1`         | `GPIO23`     | `I2C1_QT_SCL_PIN` |                      | `PWM3` (channel B)   |
+| `QT_SDA1`         | `GPIO22`     | `I2C1_QT_SDA_PIN` |                      | `PWM3` (channel A)   |
+| `A0`              | `GPIO29`     | `UART0_RX_PIN`, `UART_RX_PIN`, `ADC3` |                      | `PWM6` (channel B)   |
+| `A1`              | `GPIO28`     | `UART0_TX_PIN`, `UART_TX_PIN`, `ADC2` |                      | `PWM6` (channel A)   |
+| `A2`              | `GPIO27`     | `I2C1_SCL_PIN`, `SPI1_SDO_PIN`, `ADC1` | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `A3`              | `GPIO26`     | `I2C1_SDA_PIN`, `SPI1_SCK_PIN`, `ADC0` | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `NEOPIXEL`        | `GPIO12`     | `WS2812`          | `I2C0` (SDA)         | `PWM6` (channel A)   |
+| `NEOPIXEL_POWER`  | `GPIO11`     |                   | `I2C1` (SCL)         | `PWM5` (channel B)   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Adafruit QT Py RP2040](../machine/qtpy-rp2040)
+
+## Flashing
+
+### UF2
+
+The QT Py RP2040 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=qtpy-rp2040 [PATH TO YOUR PROGRAM]
+    ```
+
+- The QT Py RP2040 board should restart and then begin running your program.
+
+### Troubleshooting
+
+Any troubleshooting tips go here.
+
+## Notes
+
+To use the Qwiic/StemmaQT port on this board with I2C drivers you'll need to configure the `I2C1` device:
+
+```go
+i2c := machine.I2C1
+i2c.Configure(machine.I2CConfig{
+	SCL: machine.I2C1_QT_SCL_PIN,
+	SDA: machine.I2C1_QT_SDA_PIN,
+})
+```
+
+You can use the USB port to the QT Py RP2040 as a serial port.
+
+TinyGo has support for the RP2040's on-board Programmable Input/Output (PIO) block.
+
+For more informantion, see [https://github.com/tinygo-org/pio](https://github.com/tinygo-org/pio)
diff --git a/content/docs/reference/microcontrollers/qtpy.md b/content/docs/reference/microcontrollers/qtpy.md
new file mode 100644
index 00000000..5737b100
--- /dev/null
+++ b/content/docs/reference/microcontrollers/qtpy.md
@@ -0,0 +1,82 @@
+---
+title: "Adafruit Qt Py"
+weight: 3
+---
+
+The [Adafruit QtPy](https://www.adafruit.com/product/4600) is a tiny ARM development board based on the Atmel [ATSAMD21E18](https://www.microchip.com/wwwproducts/en/ATSAMD21E18) family of SoC.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `D0`              | `PA02`       | `A0`              |                      |                      |
+| `D1`              | `PA03`       | `A1`              |                      |                      |
+| `D2`              | `PA04`       | `A2`              |                      | `TCC0` (channel 0)   |
+| `D3`              | `PA05`       | `A3`              |                      | `TCC0` (channel 1)   |
+| `D4`              | `PA16`       | `A4`, `SDA_PIN`   | `I2C0` (SDA)         | `TCC2` (channel 0), `TCC0` (channel 2) |
+| `D5`              | `PA17`       | `SCL_PIN`         | `I2C0` (SCL)         | `TCC2` (channel 1), `TCC0` (channel 3) |
+| `D6`              | `PA06`       | `UART_TX_PIN`     |                      | `TCC1` (channel 0)   |
+| `D7`              | `PA07`       | `UART_RX_PIN`     |                      | `TCC1` (channel 1)   |
+| `D8`              | `PA11`       | `SPI0_SCK_PIN`    |                      | `TCC1` (channel 1), `TCC0` (channel 3) |
+| `D9`              | `PA09`       | `SPI0_SDI_PIN`    |                      | `TCC0` (channel 1), `TCC1` (channel 3) |
+| `D10`             | `PA10`       | `SPI0_SDO_PIN`, `I2S_SCK_PIN` |                      | `TCC1` (channel 0), `TCC0` (channel 2) |
+| `D11`             | `PA18`       | `NEOPIXELS`, `WS2812` |                      | `TCC0` (channel 2)   |
+| `D12`             | `PA15`       | `NEOPIXELS_POWER` |                      | `TCC0` (channel 1)   |
+| `D13`             | `PA27`       |                   |                      |                      |
+| `D14`             | `PA23`       |                   |                      | `TCC0` (channel 1)   |
+| `D15`             | `PA19`       |                   |                      | `TCC0` (channel 3)   |
+| `D16`             | `PA22`       |                   |                      | `TCC0` (channel 0)   |
+| `D17`             | `PA08`       | `I2S_SDO_PIN`     |                      | `TCC0` (channel 0), `TCC1` (channel 2) |
+| `USBCDC_DM_PIN`   | `PA24`       |                   |                      | `TCC1` (channel 2)   |
+| `USBCDC_DP_PIN`   | `PA25`       |                   |                      | `TCC1` (channel 3)   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Adafruit QtPy](../machine/qtpy)
+
+## Flashing
+
+### UF2
+
+The QtPy comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Plug your QtPy into your computer's USB port.
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=qtpy [PATH TO YOUR PROGRAM]
+    ```
+
+- The QtPy board should restart and then begin running your program.
+
+### Troubleshooting
+
+If you have troubles getting your QtPy board to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the QtPy board ready to receive code.
+- The QtPy board will appear to your computer like a USB drive.
+- Now try running the `tinygo flash` command as above:
+
+    ```shell
+    tinygo flash -target=qtpy [PATH TO YOUR PROGRAM]
+    ```
+
+Once you have updated your QtPy board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You can use the USB port to the QtPy as a serial port. `UART0` refers to this connection.
diff --git a/content/microcontrollers/reelboard.md b/content/docs/reference/microcontrollers/reelboard.md
similarity index 55%
rename from content/microcontrollers/reelboard.md
rename to content/docs/reference/microcontrollers/reelboard.md
index 8141b9fc..d65f38c7 100644
--- a/content/microcontrollers/reelboard.md
+++ b/content/docs/reference/microcontrollers/reelboard.md
@@ -1,5 +1,5 @@
 ---
-title: "reel board"
+title: "Phytec reel board"
 weight: 3
 ---
 
@@ -13,11 +13,36 @@ It is equipped with an Electrophoretic (electronic ink) Display (EPD), along wit
 | --------- | ------------- | ----- |
 | GPIO      | YES | YES |
 | UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | Not yet |
-| PWM      | YES | Not yet |
-| Bluetooth      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+| Bluetooth | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `LED_RED`         | `P0_11`      | `LED2`            |
+| `LED_GREEN`       | `P0_12`      | `LED3`            |
+| `LED_BLUE`        | `P1_09`      | `LED4`            |
+| `LED_YELLOW`      | `P0_13`      | `LED1`, `LED`     |
+| `EPD_BUSY_PIN`    | `P0_14`      |                   |
+| `EPD_RESET_PIN`   | `P0_15`      |                   |
+| `EPD_DC_PIN`      | `P0_16`      |                   |
+| `EPD_CS_PIN`      | `P0_17`      |                   |
+| `EPD_SCK_PIN`     | `P0_19`      |                   |
+| `EPD_SDO_PIN`     | `P0_20`      |                   |
+| `POWER_SUPPLY_PIN` | `P1_00`      |                   |
+| `BUTTON`          | `P0_07`      |                   |
+| `UART_TX_PIN`     | `P0_06`      |                   |
+| `UART_RX_PIN`     | `P0_08`      |                   |
+| `SDA_PIN`         | `P0_26`      |                   |
+| `SCL_PIN`         | `P0_27`      |                   |
+| `SPI0_SCK_PIN`    | `P1_15`      |                   |
+| `SPI0_SDO_PIN`    | `P1_13`      |                   |
+| `SPI0_SDI_PIN`    | `P1_14`      |                   |
 
 ## Machine Package Docs
 
diff --git a/content/docs/reference/microcontrollers/stm32f4disco.md b/content/docs/reference/microcontrollers/stm32f4disco.md
new file mode 100644
index 00000000..05723f1b
--- /dev/null
+++ b/content/docs/reference/microcontrollers/stm32f4disco.md
@@ -0,0 +1,64 @@
+---
+title: 'ST Micro STM32F407 "Discovery"'
+weight: 3
+---
+
+The [STM32F4 Discovery](https://www.st.com/en/evaluation-tools/stm32f4discovery.html) is an ARM development board based on the ST Micro [STM32F407](https://www.st.com/resource/en/datasheet/stm32f407vg.pdf) SoC.
+
+It has an onboard LIS302DL or LIS3DSH accelerometer, MP45DT02 MEMS digital microphone, an
+CS43L22 audio DAC, 2 user buttons, and 4 user LEDs.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | Not yet |
+| USBDevice | YES | Not yet |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `LED1`            | `PD12`       | `LED_GREEN`, `LED`, `LED_BUILTIN` |
+| `LED2`            | `PD13`       | `LED_ORANGE`      |
+| `LED3`            | `PD14`       | `LED_RED`         |
+| `LED4`            | `PD15`       | `LED_BLUE`        |
+| `BUTTON`          | `PA0`        | `ADC0`            |
+| `ADC1`            | `PA1`        |                   |
+| `ADC2`            | `PA2`        | `UART_TX_PIN`     |
+| `ADC3`            | `PA3`        | `UART_RX_PIN`     |
+| `ADC4`            | `PA4`        |                   |
+| `ADC5`            | `PA5`        | `SPI1_SCK_PIN`, `SPI0_SCK_PIN` |
+| `ADC6`            | `PA6`        | `SPI1_SDI_PIN`, `SPI0_SDI_PIN` |
+| `ADC7`            | `PA7`        | `SPI1_SDO_PIN`, `SPI0_SDO_PIN` |
+| `ADC8`            | `PB0`        |                   |
+| `ADC9`            | `PB1`        |                   |
+| `ADC10`           | `PC0`        |                   |
+| `ADC11`           | `PC1`        |                   |
+| `ADC12`           | `PC2`        |                   |
+| `ADC13`           | `PC3`        |                   |
+| `ADC14`           | `PC4`        |                   |
+| `ADC15`           | `PC5`        |                   |
+| `MEMS_ACCEL_CS`   | `PE3`        |                   |
+| `MEMS_ACCEL_INT1` | `PE0`        |                   |
+| `MEMS_ACCEL_INT2` | `PE1`        |                   |
+| `I2C0_SCL_PIN`    | `PB6`        |                   |
+| `I2C0_SDA_PIN`    | `PB9`        |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the STM32F4 Discovery](../machine/stm32f4disco)
+
+## Flashing
+
+### OpenOCD
+
+Programs are loaded onto the STM32F4 Discovery with the onboard [STLink v2](https://www.st.com/en/development-tools/st-link-v2.html) hardware programmer, using the `openocd` command line utility program to perform the board flashing. You must install [OpenOCD](http://openocd.org/) before you will be able to flash the STM32F4 Discovery board with your TinyGo code.
+
+- Plug your STM32F4 Discovery into your computer's USB port.
+- Build and flash your TinyGo program using `tinygo flash -target=stm32f4disco`
diff --git a/content/docs/reference/microcontrollers/swan.md b/content/docs/reference/microcontrollers/swan.md
new file mode 100644
index 00000000..c37a4828
--- /dev/null
+++ b/content/docs/reference/microcontrollers/swan.md
@@ -0,0 +1,55 @@
+---
+title: "Blues Wireless Swan"
+weight: 3
+---
+
+The [Swan](https://blues.io/products/swan/) is an ARM development board based on the ST Micro [stm32l4r5zi](https://www.st.com/en/microcontrollers-microprocessors/stm32l4r5zi.html) SoC.
+
+The Swan has a user button and an LED, LiPo charging and USB.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | Not yet |
+| USBDevice | YES | Not yet |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `LED`             | `PE2`        |                   |
+| `UART_TX_PIN`     | `PA9`        |                   |
+| `UART_RX_PIN`     | `PA10`       |                   |
+| `I2C0_SCL_PIN`    | `PB6`        |                   |
+| `I2C0_SDA_PIN`    | `PB7`        |                   |
+| `SPI1_SCK_PIN`    | `PD1`        | `SPI0_SCK_PIN`    |
+| `SPI1_SDI_PIN`    | `PB14`       | `SPI0_SDI_PIN`    |
+| `SPI1_SDO_PIN`    | `PB15`       | `SPI0_SDO_PIN`    |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Swan](../machine/swan)
+
+## Flashing
+
+### DFU Util
+
+Programs are loaded onto the Swan using DFU mode by default. You must install [DFU Util](http://dfu-util.sourceforge.net/) before you will be able to flash the STM32F4 Discovery board with your TinyGo code.
+
+- Plug the Swan into your computer's USB port.
+- Put the Swan into DFU mode (press and hold BOOT while toggling RESET).
+- Build and flash your TinyGo program using `tinygo flash -target=swan`
+
+### ST-Link
+
+The Swan includes an SWD header that can be used with an ST Link such as the [STLINK-V3MINI](https://www.st.com/en/development-tools/stlink-v3mini.html). You must install [OpenOCD](http://openocd.org/) before you will be able to flash the Swan with your TinyGo code.
+
+- Connect the ST-Link debugger to the Swan using the ribbon cable.
+- Plug the Swan and the ST-Link into USB ports on your computer.
+- Build and flash your TinyGo program using `tinygo flash -target=swan -programmer=openocd`
diff --git a/content/docs/reference/microcontrollers/teensy36.md b/content/docs/reference/microcontrollers/teensy36.md
new file mode 100644
index 00000000..c53ed01e
--- /dev/null
+++ b/content/docs/reference/microcontrollers/teensy36.md
@@ -0,0 +1,126 @@
+---
+title: "PJRC Teensy 3.6"
+weight: 3
+---
+
+The [PJRC Teensy 3.6](https://www.pjrc.com/store/teensy36.html) is a small ARM development board based on the NXP [MK66FX1M0VMD18](https://www.nxp.com/docs/en/data-sheet/K66P144M180SF5V2.pdf) 32-bit 180 MHz ARM Cortex-M4.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | Not yet |
+| I2C       | YES | Not yet |
+| ADC       | YES | YES |
+| PWM       | YES | Not yet |
+| USBDevice | YES | Not yet |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `D00`             | `PB16`       |                   |
+| `D01`             | `PB17`       |                   |
+| `D02`             | `PD00`       |                   |
+| `D03`             | `PA12`       |                   |
+| `D04`             | `PA13`       |                   |
+| `D05`             | `PD07`       |                   |
+| `D06`             | `PD04`       |                   |
+| `D07`             | `PD02`       |                   |
+| `D08`             | `PD03`       |                   |
+| `D09`             | `PC03`       |                   |
+| `D10`             | `PC04`       |                   |
+| `D11`             | `PC06`       |                   |
+| `D12`             | `PC07`       |                   |
+| `D13`             | `PC05`       | `LED`             |
+| `D14`             | `PD01`       |                   |
+| `D15`             | `PC00`       |                   |
+| `D16`             | `PB00`       |                   |
+| `D17`             | `PB01`       |                   |
+| `D18`             | `PB03`       |                   |
+| `D19`             | `PB02`       |                   |
+| `D20`             | `PD05`       |                   |
+| `D21`             | `PD06`       |                   |
+| `D22`             | `PC01`       |                   |
+| `D23`             | `PC02`       |                   |
+| `D24`             | `PE26`       |                   |
+| `D25`             | `PA05`       |                   |
+| `D26`             | `PA14`       |                   |
+| `D27`             | `PA15`       |                   |
+| `D28`             | `PA16`       |                   |
+| `D29`             | `PB18`       |                   |
+| `D30`             | `PB19`       |                   |
+| `D31`             | `PB10`       |                   |
+| `D32`             | `PB11`       |                   |
+| `D33`             | `PE24`       |                   |
+| `D34`             | `PE25`       |                   |
+| `D35`             | `PC08`       |                   |
+| `D36`             | `PC09`       |                   |
+| `D37`             | `PC10`       |                   |
+| `D38`             | `PC11`       |                   |
+| `D39`             | `PA17`       |                   |
+| `D40`             | `PA28`       |                   |
+| `D41`             | `PA29`       |                   |
+| `D42`             | `PA26`       |                   |
+| `D43`             | `PB20`       |                   |
+| `D44`             | `PB22`       |                   |
+| `D45`             | `PB23`       |                   |
+| `D46`             | `PB21`       |                   |
+| `D47`             | `PD08`       |                   |
+| `D48`             | `PD09`       |                   |
+| `D49`             | `PB04`       |                   |
+| `D50`             | `PB05`       |                   |
+| `D51`             | `PD14`       |                   |
+| `D52`             | `PD13`       |                   |
+| `D53`             | `PD12`       |                   |
+| `D54`             | `PD15`       |                   |
+| `D55`             | `PD11`       |                   |
+| `D56`             | `PE10`       |                   |
+| `D57`             | `PE11`       |                   |
+| `D58`             | `PE00`       |                   |
+| `D59`             | `PE01`       |                   |
+| `D60`             | `PE02`       |                   |
+| `D61`             | `PE03`       |                   |
+| `D62`             | `PE04`       |                   |
+| `D63`             | `PE05`       |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Teensy 3.6](../machine/teensy36)
+
+## Flashing
+
+### teensy_loader_cli
+
+In order to flash your TinyGo programs onto the Teensy 3.6 board, you will need to install the `teensy_loader_cli` (https://github.com/PaulStoffregen/teensy_loader_cli) on your machine.
+
+### CLI Flashing
+
+- Plug your Teensy 3.6 into your computer's USB port.
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=teensy36 [PATH TO YOUR PROGRAM]
+    ```
+
+- The Teensy 3.6 board should restart and then begin running your program.
+
+### Troubleshooting
+
+If you have troubles getting your Teensy 3.6 board to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the Teensy 3.6 board ready to receive code.
+- The Teensy 3.6 board will appear to your computer like a USB drive.
+- Now try running the command as above:
+
+    ```shell
+    tinygo flash -target=teensy36 [PATH TO YOUR PROGRAM]
+    ```
+
+Once you have updated your Teensy 3.6 board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You cannot yet use the USB port to the Teensy 3.6 as a USB CDC serial port.
diff --git a/content/docs/reference/microcontrollers/teensy40.md b/content/docs/reference/microcontrollers/teensy40.md
new file mode 100644
index 00000000..dc5a3c5c
--- /dev/null
+++ b/content/docs/reference/microcontrollers/teensy40.md
@@ -0,0 +1,102 @@
+---
+title: "PJRC Teensy 4.0"
+weight: 3
+---
+
+The [PJRC Teensy 4.0](https://www.pjrc.com/store/teensy40.html) is a small ARM development board based on the NXP [iMXRT1062](https://www.nxp.com/docs/en/nxp/data-sheets/IMXRT1060CEC.pdf) 32-bit 600 MHz ARM Cortex-M7.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | Not yet |
+| USBDevice | YES | Not yet |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `D0`              | `PA3`        | `UART_RX_PIN`, `UART1_RX_PIN`, `SPI2_CS_PIN` |
+| `D1`              | `PA2`        | `UART_TX_PIN`, `UART1_TX_PIN`, `SPI2_SDI_PIN` |
+| `D2`              | `PD4`        |                   |
+| `D3`              | `PD5`        |                   |
+| `D4`              | `PD6`        |                   |
+| `D5`              | `PD8`        |                   |
+| `D6`              | `PB10`       |                   |
+| `D7`              | `PB17`       | `UART2_RX_PIN`    |
+| `D8`              | `PB16`       | `UART2_TX_PIN`    |
+| `D9`              | `PB11`       |                   |
+| `D10`             | `PB0`        | `SPI_CS_PIN`, `SPI1_CS_PIN` |
+| `D11`             | `PB2`        | `SPI_SDO_PIN`, `SPI1_SDO_PIN` |
+| `D12`             | `PB1`        | `SPI_SDI_PIN`, `SPI1_SDI_PIN` |
+| `D13`             | `PB3`        | `LED`, `SPI_SCK_PIN`, `SPI1_SCK_PIN` |
+| `D14`             | `PA18`       | `A0`, `UART3_TX_PIN` |
+| `D15`             | `PA19`       | `A1`, `UART3_RX_PIN` |
+| `D16`             | `PA23`       | `A2`, `UART4_RX_PIN`, `I2C2_SCL_PIN` |
+| `D17`             | `PA22`       | `A3`, `UART4_TX_PIN`, `I2C2_SDA_PIN` |
+| `D18`             | `PA17`       | `A4`, `I2C_SDA_PIN`, `I2C1_SDA_PIN` |
+| `D19`             | `PA16`       | `A5`, `I2C_SCL_PIN`, `I2C1_SCL_PIN` |
+| `D20`             | `PA26`       | `A6`, `UART5_TX_PIN` |
+| `D21`             | `PA27`       | `A7`, `UART5_RX_PIN` |
+| `D22`             | `PA24`       | `A8`              |
+| `D23`             | `PA25`       | `A9`              |
+| `D24`             | `PA12`       | `A10`, `UART6_TX_PIN`, `I2C3_SCL_PIN` |
+| `D25`             | `PA13`       | `A11`, `UART6_RX_PIN`, `I2C3_SDA_PIN` |
+| `D26`             | `PA30`       | `A12`, `SPI2_SDO_PIN` |
+| `D27`             | `PA31`       | `A13`, `SPI2_SCK_PIN` |
+| `D28`             | `PC18`       | `UART7_RX_PIN`    |
+| `D29`             | `PD31`       | `UART7_TX_PIN`    |
+| `D30`             | `PC23`       |                   |
+| `D31`             | `PC22`       |                   |
+| `D32`             | `PB12`       |                   |
+| `D33`             | `PD7`        |                   |
+| `D34`             | `PC15`       | `SPI3_SDI_PIN`    |
+| `D35`             | `PC14`       | `SPI3_SDO_PIN`    |
+| `D36`             | `PC13`       | `SPI3_CS_PIN`     |
+| `D37`             | `PC12`       | `SPI3_SCK_PIN`    |
+| `D38`             | `PC17`       |                   |
+| `D39`             | `PC16`       |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Teensy 4.0](../machine/teensy40)
+
+## Flashing
+
+### teensy_loader_cli
+
+In order to flash your TinyGo programs onto the Teensy 4.0 board, you will need to install the `teensy_loader_cli` (https://github.com/PaulStoffregen/teensy_loader_cli) on your machine.
+
+### CLI Flashing
+
+- Plug your Teensy 4.0 into your computer's USB port.
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=teensy36 [PATH TO YOUR PROGRAM]
+    ```
+
+- The Teensy 4.0 board should restart and then begin running your program.
+
+### Troubleshooting
+
+If you have troubles getting your Teensy 4.0 board to receive code, try this:
+
+- Press the "RESET" button on the board two times to get the Teensy 4.0 board ready to receive code.
+- The Teensy 4.0 board will appear to your computer like a USB drive.
+- Now try running the command as above:
+
+    ```shell
+    tinygo flash -target=teensy40 [PATH TO YOUR PROGRAM]
+    ```
+
+Once you have updated your Teensy 4.0 board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You cannot yet use the USB port to the Teensy 4.0 as a USB CDC serial port.
diff --git a/content/docs/reference/microcontrollers/thingplus-rp2040.md b/content/docs/reference/microcontrollers/thingplus-rp2040.md
new file mode 100644
index 00000000..bc3debf6
--- /dev/null
+++ b/content/docs/reference/microcontrollers/thingplus-rp2040.md
@@ -0,0 +1,88 @@
+---
+title: "Sparkfun Thing Plus RP2040"
+weight: 3
+---
+
+The [Sparkfun Thing Plus RP2040](https://www.sparkfun.com/products/17745) is a tiny development board based on the Raspberry Pi [RP2040](https://datasheets.raspberrypi.org/rp2040/rp2040-datasheet.pdf) microcontroller. 
+
+Peripherals: 
+- ws2812 Neopixel
+- sdcard
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `GP0`             | `GPIO0`      | `UART0_TX_PIN`, `UART_TX_PIN` | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `GP1`             | `GPIO1`      | `UART0_RX_PIN`, `UART_RX_PIN` | `I2C0` (SCL)         | `PWM0` (channel B)   |
+| `GP2`             | `GPIO2`      | `SPI0_SCK_PIN`    | `I2C1` (SDA)         | `PWM1` (channel A)   |
+| `GP3`             | `GPIO3`      | `SPI0_SDO_PIN`    | `I2C1` (SCL)         | `PWM1` (channel B)   |
+| `GP4`             | `GPIO4`      | `SPI0_SDI_PIN`    | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `GP6`             | `GPIO6`      | `I2C0_SCL_PIN`, `I2C1_SDA_PIN`, `SDA_PIN` | `I2C1` (SDA)         | `PWM3` (channel A)   |
+| `GP7`             | `GPIO7`      | `I2C0_SDA_PIN`, `I2C1_SCL_PIN`, `SCL_PIN` | `I2C1` (SCL)         | `PWM3` (channel B)   |
+| `GP8`             | `GPIO8`      | `WS2812`          | `I2C0` (SDA)         | `PWM4` (channel A)   |
+| `GP9`             | `GPIO9`      |                   | `I2C0` (SCL)         | `PWM4` (channel B)   |
+| `GP10`            | `GPIO10`     |                   | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `GP11`            | `GPIO11`     |                   | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `GP12`            | `GPIO12`     | `SPI1_SDI_PIN`    | `I2C0` (SDA)         | `PWM6` (channel A)   |
+| `GP14`            | `GPIO14`     | `SPI1_SCK_PIN`    | `I2C1` (SDA)         | `PWM7` (channel A)   |
+| `GP15`            | `GPIO15`     | `SPI1_SDO_PIN`    | `I2C1` (SCL)         | `PWM7` (channel B)   |
+| `GP16`            | `GPIO16`     |                   | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `GP17`            | `GPIO17`     |                   | `I2C0` (SCL)         | `PWM0` (channel B)   |
+| `GP18`            | `GPIO18`     |                   | `I2C1` (SDA)         | `PWM1` (channel A)   |
+| `GP19`            | `GPIO19`     |                   | `I2C1` (SCL)         | `PWM1` (channel B)   |
+| `GP20`            | `GPIO20`     |                   | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `GP21`            | `GPIO21`     |                   | `I2C0` (SCL)         | `PWM2` (channel B)   |
+| `GP22`            | `GPIO22`     |                   |                      | `PWM3` (channel A)   |
+| `GP23`            | `GPIO23`     |                   |                      | `PWM3` (channel B)   |
+| `GP25`            | `GPIO25`     | `LED`             |                      | `PWM4` (channel B)   |
+| `GP26`            | `GPIO26`     | `A0`, `ADC0`      | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `GP27`            | `GPIO27`     | `A1`, `ADC1`      | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `GP28`            | `GPIO28`     | `A2`, `ADC2`      |                      | `PWM6` (channel A)   |
+| `GP29`            | `GPIO29`     | `A3`, `ADC3`      |                      | `PWM6` (channel B)   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Sparkfun Thing Plus RP2040](../machine/thingplus-rp2040)
+
+## Flashing
+
+### UF2
+
+The Sparkfun Thing Plus RP2040 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=thingplus-rp2040 [PATH TO YOUR PROGRAM]
+    ```
+
+- The Thing Plus RP2040 board should restart and run your program.
+
+### Troubleshooting
+
+Any troubleshooting tips go here.
+
+## Notes
+
+You can use the USB port to the Thing Plus RP2040 as a serial port.
+
+The Neopixel LED and the SD Card are supported by [tinygo drivers](https://github.com/tinygo-org/drivers)
+
+TinyGo has support for the RP2040's on-board Programmable Input/Output (PIO) block.
+
+For more informantion, see [https://github.com/tinygo-org/pio](https://github.com/tinygo-org/pio)
diff --git a/content/microcontrollers/trinket-m0.md b/content/docs/reference/microcontrollers/trinket-m0.md
similarity index 51%
rename from content/microcontrollers/trinket-m0.md
rename to content/docs/reference/microcontrollers/trinket-m0.md
index ebbb3275..67267769 100644
--- a/content/microcontrollers/trinket-m0.md
+++ b/content/docs/reference/microcontrollers/trinket-m0.md
@@ -11,10 +11,24 @@ The [Adafruit Trinket M0](https://www.adafruit.com/product/3500) is a tiny ARM d
 | --------- | ------------- | ----- |
 | GPIO      | YES | YES |
 | UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `D0`              | `PA08`       | `A2`, `SDA_PIN`, `I2S_SDO_PIN` | `I2C0` (SDA)         | `TCC0` (channel 0), `TCC1` (channel 2) |
+| `D1`              | `PA02`       | `A0`              |                      |                      |
+| `D2`              | `PA09`       | `A1`, `SPI0_SDI_PIN`, `SCL_PIN` | `I2C0` (SCL)         | `TCC0` (channel 1), `TCC1` (channel 3) |
+| `D3`              | `PA07`       | `A3`, `UART_RX_PIN`, `SPI0_SCK_PIN` |                      | `TCC1` (channel 1)   |
+| `D4`              | `PA06`       | `A4`, `UART_TX_PIN`, `SPI0_SDO_PIN` |                      | `TCC1` (channel 0)   |
+| `D13`             | `PA10`       | `LED`, `I2S_SCK_PIN` |                      | `TCC1` (channel 0), `TCC0` (channel 2) |
+| `USBCDC_DM_PIN`   | `PA24`       |                   |                      | `TCC1` (channel 2)   |
+| `USBCDC_DP_PIN`   | `PA25`       |                   |                      | `TCC1` (channel 3)   |
 
 ## Machine Package Docs
 
@@ -54,3 +68,5 @@ Once you have updated your Trinket M0 board the first time, after that you shoul
 ## Notes
 
 You can use the USB port to the Trinket M0 as a serial port. `UART0` refers to this connection.
+
+The DotStar LED on the Trinket M0 can be accessed using the [APA102](https://pkg.go.dev/tinygo.org/x/drivers/apa102) driver via a software SPI on the `PA01` and `PA00` pins
diff --git a/content/docs/reference/microcontrollers/trinkey-qt2040.md b/content/docs/reference/microcontrollers/trinkey-qt2040.md
new file mode 100644
index 00000000..70047109
--- /dev/null
+++ b/content/docs/reference/microcontrollers/trinkey-qt2040.md
@@ -0,0 +1,61 @@
+---
+title: "Adafruit Trinkey QT2040"
+weight: 3
+---
+
+The [Adafruit Trinkey QT2040](https://www.adafruit.com/product/5056) is a tiny development board based on the Raspberry Pi [RP2040](https://datasheets.raspberrypi.org/rp2040/rp2040-datasheet.pdf) microcontroller.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `NEOPIXEL`        | `GPIO27`     | `WS2812`, `ADC1`  | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `I2C0_SDA_PIN`    | `GPIO16`     |                   | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `I2C0_SCL_PIN`    | `GPIO17`     |                   | `I2C0` (SCL)         | `PWM0` (channel B)   |
+| `ADC0`            | `GPIO26`     |                   | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `ADC2`            | `GPIO28`     |                   |                      | `PWM6` (channel A)   |
+| `ADC3`            | `GPIO29`     |                   |                      | `PWM6` (channel B)   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Adafruit Trinkey QT2040](../machine/trinkey-qt2040)
+
+## Flashing
+
+### UF2
+
+The Trinkey QT2040 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=trinkey-qt2040 [PATH TO YOUR PROGRAM]
+    ```
+
+- The Trinkey QT2040 board should restart and then begin running your program.
+
+### Troubleshooting
+
+Any troubleshooting tips go here.
+
+## Notes
+
+You can use the USB port to the Trinkey QT2040 as a serial port.
+
+TinyGo has support for the RP2040's on-board Programmable Input/Output (PIO) block.
+
+For more informantion, see [https://github.com/tinygo-org/pio](https://github.com/tinygo-org/pio)
diff --git a/content/docs/reference/microcontrollers/tufty2040.md b/content/docs/reference/microcontrollers/tufty2040.md
new file mode 100644
index 00000000..73173e6d
--- /dev/null
+++ b/content/docs/reference/microcontrollers/tufty2040.md
@@ -0,0 +1,86 @@
+---
+title: "Pimoroni Tufty2040"
+weight: 3
+---
+
+The [Pimoroni Tufty2040](https://shop.pimoroni.com/products/tufty-2040) is a tiny development board based on the Raspberry Pi [RP2040](https://datasheets.raspberrypi.org/rp2040/rp2040-datasheet.pdf) microcontroller.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `LED`             | `GPIO25`     | `USER_LED`        |                      | `PWM4` (channel B)   |
+| `BUTTON_A`        | `GPIO7`      |                   | `I2C1` (SCL)         | `PWM3` (channel B)   |
+| `BUTTON_B`        | `GPIO8`      |                   | `I2C0` (SDA)         | `PWM4` (channel A)   |
+| `BUTTON_C`        | `GPIO9`      |                   | `I2C0` (SCL)         | `PWM4` (channel B)   |
+| `BUTTON_UP`       | `GPIO22`     |                   |                      | `PWM3` (channel A)   |
+| `BUTTON_DOWN`     | `GPIO6`      |                   | `I2C1` (SDA)         | `PWM3` (channel A)   |
+| `BUTTON_USER`     | `GPIO23`     |                   |                      | `PWM3` (channel B)   |
+| `LCD_BACKLIGHT`   | `GPIO2`      |                   | `I2C1` (SDA)         | `PWM1` (channel A)   |
+| `LCD_CS`          | `GPIO10`     |                   | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `LCD_DC`          | `GPIO11`     |                   | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `LCD_WR`          | `GPIO12`     |                   | `I2C0` (SDA)         | `PWM6` (channel A)   |
+| `LCD_RD`          | `GPIO13`     |                   | `I2C0` (SCL)         | `PWM6` (channel B)   |
+| `LCD_DB0`         | `GPIO14`     |                   | `I2C1` (SDA)         | `PWM7` (channel A)   |
+| `LCD_DB1`         | `GPIO15`     |                   | `I2C1` (SCL)         | `PWM7` (channel B)   |
+| `LCD_DB2`         | `GPIO16`     |                   | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `LCD_DB3`         | `GPIO17`     |                   | `I2C0` (SCL)         | `PWM0` (channel B)   |
+| `LCD_DB4`         | `GPIO18`     |                   | `I2C1` (SDA)         | `PWM1` (channel A)   |
+| `LCD_DB5`         | `GPIO19`     |                   | `I2C1` (SCL)         | `PWM1` (channel B)   |
+| `LCD_DB6`         | `GPIO20`     |                   | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `LCD_DB7`         | `GPIO21`     |                   | `I2C0` (SCL)         | `PWM2` (channel B)   |
+| `VBUS_DETECT`     | `GPIO24`     |                   |                      | `PWM4` (channel A)   |
+| `BATTERY`         | `GPIO29`     | `ADC3`            |                      | `PWM6` (channel B)   |
+| `LIGHT_SENSE`     | `GPIO26`     | `ADC0`            | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `SENSOR_POWER`    | `GPIO27`     | `ADC1`            | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `I2C0_SDA_PIN`    | `GPIO4`      |                   | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `I2C0_SCL_PIN`    | `GPIO5`      |                   | `I2C0` (SCL)         | `PWM2` (channel B)   |
+| `UART0_TX_PIN`    | `GPIO0`      | `UART_TX_PIN`     | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `UART0_RX_PIN`    | `GPIO1`      | `UART_RX_PIN`     | `I2C0` (SCL)         | `PWM0` (channel B)   |
+| `ADC2`            | `GPIO28`     |                   |                      | `PWM6` (channel A)   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Pimoroni Tufty2040](../machine/tufty2040)
+
+## Flashing
+
+### UF2
+
+The Tufty2040 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=tufty2040 [PATH TO YOUR PROGRAM]
+    ```
+
+- The Tufty2040 board should restart and then begin running your program.
+
+### Troubleshooting
+
+Any troubleshooting tips go here.
+
+## Notes
+
+You can use the USB port to the Tufty2040 as a serial port.
+
+TinyGo has support for the RP2040's on-board Programmable Input/Output (PIO) block.
+
+For more informantion, see [https://github.com/tinygo-org/pio](https://github.com/tinygo-org/pio)
+
+For support for the Tufty's display please see [https://github.com/tinygo-org/pio/tree/main/rp2-pio/examples/tufty](https://github.com/tinygo-org/pio/tree/main/rp2-pio/examples/tufty)
diff --git a/content/docs/reference/microcontrollers/waveshare-rp2040-zero.md b/content/docs/reference/microcontrollers/waveshare-rp2040-zero.md
new file mode 100644
index 00000000..8683f664
--- /dev/null
+++ b/content/docs/reference/microcontrollers/waveshare-rp2040-zero.md
@@ -0,0 +1,85 @@
+---
+title: "Waveshare RP2040-Zero"
+weight: 3
+---
+
+The [Waveshare RP2040-Zero](https://www.waveshare.com/wiki/RP2040-Zero) is a tiny development board based on the Raspberry Pi [RP2040](https://datasheets.raspberrypi.org/rp2040/rp2040-datasheet.pdf) microcontroller.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `D0`              | `GPIO0`      | `I2C0_SDA_PIN`, `UART0_TX_PIN`, `UART_TX_PIN` | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `D1`              | `GPIO1`      | `I2C0_SCL_PIN`, `UART0_RX_PIN`, `UART_RX_PIN` | `I2C0` (SCL)         | `PWM0` (channel B)   |
+| `D2`              | `GPIO2`      | `I2C1_SDA_PIN`    | `I2C1` (SDA)         | `PWM1` (channel A)   |
+| `D3`              | `GPIO3`      | `I2C1_SCL_PIN`, `SPI0_SDO_PIN` | `I2C1` (SCL)         | `PWM1` (channel B)   |
+| `D4`              | `GPIO4`      | `SPI0_SDI_PIN`    | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `D5`              | `GPIO5`      |                   | `I2C0` (SCL)         | `PWM2` (channel B)   |
+| `D6`              | `GPIO6`      | `SPI0_SCK_PIN`    | `I2C1` (SDA)         | `PWM3` (channel A)   |
+| `D7`              | `GPIO7`      |                   | `I2C1` (SCL)         | `PWM3` (channel B)   |
+| `D8`              | `GPIO8`      | `UART1_TX_PIN`    | `I2C0` (SDA)         | `PWM4` (channel A)   |
+| `D9`              | `GPIO9`      | `UART1_RX_PIN`    | `I2C0` (SCL)         | `PWM4` (channel B)   |
+| `D10`             | `GPIO10`     | `SPI1_SCK_PIN`    | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `D11`             | `GPIO11`     | `SPI1_SDO_PIN`    | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `D12`             | `GPIO12`     | `SPI1_SDI_PIN`    | `I2C0` (SDA)         | `PWM6` (channel A)   |
+| `D13`             | `GPIO13`     |                   | `I2C0` (SCL)         | `PWM6` (channel B)   |
+| `D14`             | `GPIO14`     |                   | `I2C1` (SDA)         | `PWM7` (channel A)   |
+| `D15`             | `GPIO15`     |                   | `I2C1` (SCL)         | `PWM7` (channel B)   |
+| `D16`             | `GPIO16`     | `NEOPIXEL`, `WS2812` | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `D17`             | `GPIO17`     |                   | `I2C0` (SCL)         | `PWM0` (channel B)   |
+| `D18`             | `GPIO18`     |                   | `I2C1` (SDA)         | `PWM1` (channel A)   |
+| `D19`             | `GPIO19`     |                   | `I2C1` (SCL)         | `PWM1` (channel B)   |
+| `D20`             | `GPIO20`     |                   | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `D21`             | `GPIO21`     |                   | `I2C0` (SCL)         | `PWM2` (channel B)   |
+| `D22`             | `GPIO22`     |                   |                      | `PWM3` (channel A)   |
+| `D23`             | `GPIO23`     |                   |                      | `PWM3` (channel B)   |
+| `D24`             | `GPIO24`     |                   |                      | `PWM4` (channel A)   |
+| `D25`             | `GPIO25`     |                   |                      | `PWM4` (channel B)   |
+| `D26`             | `GPIO26`     | `A0`, `ADC0`      | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `D27`             | `GPIO27`     | `A1`, `ADC1`      | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `D28`             | `GPIO28`     | `A2`, `ADC2`      |                      | `PWM6` (channel A)   |
+| `D29`             | `GPIO29`     | `A3`, `ADC3`      |                      | `PWM6` (channel B)   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Waveshare RP2040-Zero](../machine/waveshare-rp2040-zero)
+
+## Flashing
+
+### UF2
+
+The Waveshare RP2040-Zero comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=waveshare-rp2040-zero [PATH TO YOUR PROGRAM]
+    ```
+
+- The Waveshare RP2040-Zero board should restart and then begin running your program.
+
+### Troubleshooting
+
+Any troubleshooting tips go here.
+
+## Notes
+
+You can use the USB port to the Waveshare RP2040-Zero as a serial port.
+
+TinyGo has support for the RP2040's on-board Programmable Input/Output (PIO) block.
+
+For more informantion, see [https://github.com/tinygo-org/pio](https://github.com/tinygo-org/pio)
diff --git a/content/docs/reference/microcontrollers/wioterminal.md b/content/docs/reference/microcontrollers/wioterminal.md
new file mode 100644
index 00000000..1b4dff3a
--- /dev/null
+++ b/content/docs/reference/microcontrollers/wioterminal.md
@@ -0,0 +1,154 @@
+---
+title: "Seeed Wio Terminal"
+weight: 3
+---
+
+The [Seeed Wio Terminal](https://www.seeedstudio.com/Wio-Terminal-p-4509.html) is a tiny ARM development board based on the Atmel [ATSAMD51P20](https://www.microchip.com/wwwproducts/en/ATSAMD51P20A) family of SoC.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `ADC0`            | `PB08`       | `D0`, `A0`, `BCM27`, `RPI_A0` |                      |                      |
+| `ADC1`            | `PB09`       | `D1`, `A1`, `BCM22`, `RPI_A1` |                      |                      |
+| `ADC2`            | `PA07`       | `D2`, `A2`, `BCM23`, `RPI_A2` |                      |                      |
+| `ADC3`            | `PB04`       | `D3`, `A3`, `BCM24`, `RPI_A3` |                      |                      |
+| `ADC4`            | `PB05`       | `D4`, `A4`, `BCM25`, `RPI_A4` |                      |                      |
+| `ADC5`            | `PB06`       | `D5`, `A5`, `BCM12`, `RPI_A5` |                      |                      |
+| `ADC6`            | `PA04`       | `D6`, `A6`, `BCM13`, `RPI_A6` |                      |                      |
+| `ADC7`            | `PB07`       | `D7`, `A7`, `BCM16`, `RPI_A7` |                      |                      |
+| `ADC8`            | `PA06`       | `D8`, `A8`, `BCM26`, `RPI_A8` |                      |                      |
+| `LED`             | `PA15`       | `PIN_LED_13`, `PIN_LED_RXL`, `PIN_LED_TXL`, `PIN_LED`, `PIN_LED2`, `PIN_LED3`, `LED_BUILTIN`, `PIN_NEOPIXEL` |                      | `TCC2` (channel 1), `TCC1` (channel 3) |
+| `BUTTON`          | `PC26`       | `BUTTON_1`, `WIO_KEY_A` |                      |                      |
+| `BCM0`            | `PA13`       | `PIN_WIRE1_SDA`, `SDA1`, `PIN_GYROSCOPE_WIRE_SDA`, `WIO_LIS3DH_SDA`, `SDA0_PIN` | `I2C0` (SCL)         | `TCC0` (channel 7), `TCC1` (channel 3) |
+| `BCM1`            | `PA12`       | `PIN_WIRE1_SCL`, `SCL1`, `PIN_GYROSCOPE_WIRE_SCL`, `WIO_LIS3DH_SCL`, `SCL0_PIN` | `I2C0` (SDA)         | `TCC0` (channel 6), `TCC1` (channel 2) |
+| `BCM2`            | `PA17`       | `PIN_WIRE_SDA`, `SDA`, `SDA1_PIN`, `SDA_PIN` | `I2C1` (SCL)         | `TCC1` (channel 1), `TCC0` (channel 5) |
+| `BCM3`            | `PA16`       | `PIN_WIRE_SCL`, `SCL`, `SCL1_PIN`, `SCL_PIN` | `I2C1` (SDA)         | `TCC1` (channel 0), `TCC0` (channel 4) |
+| `BCM4`            | `PB14`       | `GCLK0`           |                      | `TCC4` (channel 0), `TCC0` (channel 2) |
+| `BCM5`            | `PB12`       | `GCLK1`           |                      | `TCC3` (channel 0), `TCC0` (channel 0) |
+| `BCM6`            | `PB13`       | `GCLK2`           |                      | `TCC3` (channel 1), `TCC0` (channel 1) |
+| `BCM7`            | `PA05`       | `PIN_DAC1`        |                      |                      |
+| `BCM8`            | `PB01`       | `PIN_SPI_SS`, `SS` |                      |                      |
+| `BCM9`            | `PB00`       | `PIN_SPI_SDI`, `SDI`, `SPI0_SDI_PIN` |                      |                      |
+| `BCM10`           | `PB02`       | `PIN_SPI_SDO`, `SDO`, `SPI0_SDO_PIN` |                      | `TCC2` (channel 2)   |
+| `BCM11`           | `PB03`       | `PIN_SPI_SCK`, `SCK`, `SPI0_SCK_PIN` |                      | `TCC2` (channel 3)   |
+| `BCM14`           | `PB27`       | `PIN_SERIAL1_RX`, `UART_RX_PIN` |                      | `TCC1` (channel 3)   |
+| `BCM15`           | `PB26`       | `PIN_SERIAL1_TX`, `UART_TX_PIN` |                      | `TCC1` (channel 2)   |
+| `BCM17`           | `PA02`       | `PIN_DAC0`        |                      |                      |
+| `BCM18`           | `PB28`       | `FPC1`, `I2S_SCK_PIN` |                      | `TCC1` (channel 4)   |
+| `BCM19`           | `PA20`       | `PIN_I2S_FS`, `I2S_LRCLK`, `I2S_WS_PIN` |                      | `TCC1` (channel 4), `TCC0` (channel 0) |
+| `BCM20`           | `PA21`       | `PIN_I2S_SDI`, `I2S_SDIN`, `I2S_SDI_PIN` |                      | `TCC1` (channel 5), `TCC0` (channel 1) |
+| `BCM21`           | `PA22`       | `PIN_I2S_SDO`, `I2S_SDOUT`, `I2S_SDO_PIN` | `I2C1` (SDA)         | `TCC1` (channel 6), `TCC0` (channel 2) |
+| `FPC2`            | `PB17`       |                   |                      | `TCC3` (channel 1), `TCC0` (channel 5) |
+| `FPC3`            | `PB29`       |                   |                      | `TCC1` (channel 5)   |
+| `FPC4`            | `PA14`       |                   |                      | `TCC2` (channel 0), `TCC1` (channel 2) |
+| `FPC5`            | `PC01`       |                   |                      |                      |
+| `FPC6`            | `PC02`       |                   |                      |                      |
+| `FPC7`            | `PC03`       |                   |                      |                      |
+| `FPC8`            | `PC04`       |                   |                      | `TCC0` (channel 0)   |
+| `FPC9`            | `PC31`       |                   |                      |                      |
+| `FPC10`           | `PD00`       |                   |                      |                      |
+| `PIN_USB_DM`      | `PA24`       | `USBCDC_DM_PIN`   |                      | `TCC2` (channel 2)   |
+| `PIN_USB_DP`      | `PA25`       | `USBCDC_DP_PIN`   |                      | `TCC2` (channel 3)   |
+| `PIN_USB_HOST_ENABLE` | `PA27`       |                   |                      |                      |
+| `BUTTON_2`        | `PC27`       | `WIO_KEY_B`       |                      |                      |
+| `BUTTON_3`        | `PC28`       | `WIO_KEY_C`       |                      |                      |
+| `SWITCH_X`        | `PD20`       | `WIO_5S_UP`       |                      | `TCC1` (channel 0)   |
+| `SWITCH_Y`        | `PD12`       | `WIO_5S_LEFT`     |                      | `TCC0` (channel 5)   |
+| `SWITCH_Z`        | `PD09`       | `WIO_5S_RIGHT`    |                      | `TCC0` (channel 2)   |
+| `SWITCH_B`        | `PD08`       | `WIO_5S_DOWN`     |                      | `TCC0` (channel 1)   |
+| `SWITCH_U`        | `PD10`       | `WIO_5S_PRESS`    |                      | `TCC0` (channel 3)   |
+| `IRQ0`            | `PC20`       |                   |                      | `TCC0` (channel 4)   |
+| `BUZZER_CTR`      | `PD11`       | `WIO_BUZZER`      |                      | `TCC0` (channel 4)   |
+| `MIC_INPUT`       | `PC30`       | `WIO_MIC`         |                      |                      |
+| `PIN_SERIAL2_RX`  | `PC23`       | `UART2_RX_PIN`    |                      | `TCC0` (channel 7)   |
+| `PIN_SERIAL2_TX`  | `PC22`       | `UART2_TX_PIN`    |                      | `TCC0` (channel 6)   |
+| `GYROSCOPE_INT1`  | `PC21`       | `WIO_LIS3DH_INT`  |                      | `TCC0` (channel 5)   |
+| `PIN_SPI1_SDI`    | `PC24`       | `SDI1`, `RTL8720D_SDI_PIN`, `SPI1_SDI_PIN` |                      |                      |
+| `PIN_SPI1_SDO`    | `PB24`       | `SDO1`, `RTL8720D_SDO_PIN`, `SPI1_SDO_PIN` |                      |                      |
+| `PIN_SPI1_SCK`    | `PB25`       | `SCK1`, `RTL8720D_SCK_PIN`, `SPI1_SCK_PIN` |                      |                      |
+| `PIN_SPI1_SS`     | `PC25`       | `SS1`, `RTL8720D_SS_PIN` |                      |                      |
+| `PIN_SPI2_SDI`    | `PC18`       | `SDI2`, `SDCARD_SDI_PIN`, `SPI2_SDI_PIN` |                      | `TCC0` (channel 2)   |
+| `PIN_SPI2_SDO`    | `PC16`       | `SDO2`, `SDCARD_SDO_PIN`, `SPI2_SDO_PIN` |                      | `TCC0` (channel 0)   |
+| `PIN_SPI2_SCK`    | `PC17`       | `SCK2`, `SDCARD_SCK_PIN`, `SPI2_SCK_PIN` |                      | `TCC0` (channel 1)   |
+| `PIN_SPI2_SS`     | `PC19`       | `SS2`, `SDCARD_SS_PIN` |                      | `TCC0` (channel 3)   |
+| `PIN_SPI3_SDI`    | `PB18`       | `SDI3`, `LCD_SDI_PIN`, `SPI3_SDI_PIN` |                      | `TCC1` (channel 0)   |
+| `PIN_SPI3_SDO`    | `PB19`       | `SDO3`, `LCD_SDO_PIN`, `SPI3_SDO_PIN` |                      | `TCC1` (channel 1)   |
+| `PIN_SPI3_SCK`    | `PB20`       | `SCK3`, `LCD_SCK_PIN`, `SPI3_SCK_PIN` |                      | `TCC1` (channel 2)   |
+| `PIN_SPI3_SS`     | `PB21`       | `SS3`, `LCD_SS_PIN` |                      | `TCC1` (channel 3)   |
+| `SDCARD_DET_PIN`  | `PD21`       |                   |                      | `TCC1` (channel 1)   |
+| `LCD_DC`          | `PC06`       |                   |                      |                      |
+| `LCD_RESET`       | `PC07`       |                   |                      |                      |
+| `LCD_BACKLIGHT`   | `PC05`       |                   |                      | `TCC0` (channel 1)   |
+| `LCD_XL`          | `PC10`       |                   |                      | `TCC0` (channel 0), `TCC1` (channel 4) |
+| `LCD_YU`          | `PC11`       |                   |                      | `TCC0` (channel 1), `TCC1` (channel 5) |
+| `LCD_XR`          | `PC12`       |                   |                      | `TCC0` (channel 2), `TCC1` (channel 6) |
+| `LCD_YD`          | `PC13`       |                   |                      | `TCC0` (channel 3), `TCC1` (channel 7) |
+| `PIN_QSPI_IO0`    | `PA08`       | `QSPI_DATA0`      |                      | `TCC0` (channel 0), `TCC1` (channel 4) |
+| `PIN_QSPI_IO1`    | `PA09`       | `QSPI_DATA1`      |                      | `TCC0` (channel 1), `TCC1` (channel 5) |
+| `PIN_QSPI_IO2`    | `PA10`       | `QSPI_DATA2`      |                      | `TCC0` (channel 2), `TCC1` (channel 6) |
+| `PIN_QSPI_IO3`    | `PA11`       | `QSPI_DATA3`      |                      | `TCC0` (channel 3), `TCC1` (channel 7) |
+| `PIN_QSPI_SCK`    | `PB10`       | `QSPI_SCK`        |                      | `TCC0` (channel 4), `TCC1` (channel 0) |
+| `PIN_QSPI_CS`     | `PB11`       | `QSPI_CS`         |                      | `TCC0` (channel 5), `TCC1` (channel 1) |
+| `PIN_I2S_SCK`     | `PB16`       | `I2S_BLCK`        |                      | `TCC3` (channel 0), `TCC0` (channel 4) |
+| `RTL8720D_CHIP_PU` | `PA18`       |                   |                      | `TCC1` (channel 2), `TCC0` (channel 6) |
+| `RTL8720D_GPIO0`  | `PA19`       |                   |                      | `TCC1` (channel 3), `TCC0` (channel 7) |
+| `SWDCLK`          | `PA30`       |                   |                      | `TCC2` (channel 0)   |
+| `SWDIO`           | `PA31`       |                   |                      | `TCC2` (channel 1)   |
+| `SWO`             | `PB30`       |                   |                      | `TCC4` (channel 0), `TCC0` (channel 6) |
+| `WIO_LIGHT`       | `PD01`       |                   |                      |                      |
+| `WIO_IR`          | `PB31`       |                   |                      | `TCC4` (channel 1), `TCC0` (channel 7) |
+| `OUTPUT_CTR_5V`   | `PC14`       |                   |                      | `TCC0` (channel 4), `TCC1` (channel 0) |
+| `OUTPUT_CTR_3V3`  | `PC15`       |                   |                      | `TCC0` (channel 5), `TCC1` (channel 1) |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Seeed Wio Terminal](../machine/wioterminal)
+
+## Flashing
+
+### UF2
+
+The Wio Terminal comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Plug your Wio Terminal into your computer's USB port.
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=wioterminal [PATH TO YOUR PROGRAM]
+    ```
+
+- The Wio Terminal board should restart and then begin running your program.
+
+### Troubleshooting
+
+If you have troubles getting your Wio Terminal board to receive code, try this:
+
+- [Slide the "RESET" switch on the board two times](https://wiki.seeedstudio.com/Wio-Terminal-Getting-Started/#faq) to get the Wio Terminal board ready to receive code.
+- The Wio Terminal board will appear to your computer like a USB drive.
+- Now try running the command as above:
+
+
+```shell
+tinygo flash -target=wioterminal [PATH TO YOUR PROGRAM]
+```
+
+Once you have updated your Wio Terminal board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+If your Linux Distro doesn't auto mount devices you have to manually mount it to /media/Arduino for the command above to work.
+You can use the USB port to the Wio Terminal as a serial port. `UART0` refers to this connection.
diff --git a/content/docs/reference/microcontrollers/x9pro.md b/content/docs/reference/microcontrollers/x9pro.md
new file mode 100644
index 00000000..7735a5ea
--- /dev/null
+++ b/content/docs/reference/microcontrollers/x9pro.md
@@ -0,0 +1,42 @@
+---
+title: "X9 Pro Smartwatch"
+weight: 3
+---
+
+Info here
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | ?   | ?   |
+| UART      | ?   | ?   |
+| SPI       | ?   | ?   |
+| I2C       | ?   | ?   |
+| ADC       | ?   | ?   |
+| PWM       | ?   | ?   |
+| USBDevice | ?   | ?   |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `LED`             | `P0_04`      |                   |
+| `SPI0_SCK_PIN`    | `P0_18`      |                   |
+| `SPI0_SDI_PIN`    | `P0_19`      |                   |
+| `SPI0_SDO_PIN`    | `P0_20`      |                   |
+| `OLED_CS`         | `P0_15`      |                   |
+| `OLED_RES`        | `P0_14`      |                   |
+| `OLED_DC`         | `P0_13`      |                   |
+| `OLED_SCK`        | `P0_12`      |                   |
+| `OLED_SDO`        | `P0_11`      |                   |
+| `OLED_LED_POW`    | `P0_16`      |                   |
+| `OLED_IC_POW`     | `P0_17`      |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the X9 Pro](../machine/x9pro)
+
+## Flashing
+
+How to do it...
diff --git a/content/docs/reference/microcontrollers/xiao-ble.md b/content/docs/reference/microcontrollers/xiao-ble.md
new file mode 100644
index 00000000..5f52a5d2
--- /dev/null
+++ b/content/docs/reference/microcontrollers/xiao-ble.md
@@ -0,0 +1,76 @@
+---
+title: "Seeed XIAO BLE"
+weight: 3
+---
+
+The [Seeed XIAO BLE](https://www.seeedstudio.com/Seeed-XIAO-BLE-nRF52840-p-5201.html) is a tiny ARM development board based on the Nordic Semiconductor [nrf52840](https://www.nordicsemi.com/eng/Products/nRF52840) processor.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+| Bluetooth | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names |
+| ----------------- | ------------ | ----------------- |
+| `D0`              | `P0_02`      | `A0`              |
+| `D1`              | `P0_03`      | `A1`              |
+| `D2`              | `P0_28`      | `A2`              |
+| `D3`              | `P0_29`      | `A3`              |
+| `D4`              | `P0_04`      | `A4`, `SDA0_PIN`  |
+| `D5`              | `P0_05`      | `A5`, `SCL0_PIN`  |
+| `D6`              | `P1_11`      | `UART_TX_PIN`     |
+| `D7`              | `P1_12`      | `UART_RX_PIN`     |
+| `D8`              | `P1_13`      | `SPI0_SCK_PIN`    |
+| `D9`              | `P1_14`      | `SPI0_SDO_PIN`    |
+| `D10`             | `P1_15`      | `SPI0_SDI_PIN`    |
+| `LED`             | `P0_17`      | `LED_CHG`         |
+| `LED1`            | `P0_26`      | `LED_RED`         |
+| `LED2`            | `P0_30`      | `LED_GREEN`       |
+| `LED3`            | `P0_06`      | `LED_BLUE`        |
+| `SDA_PIN`         | `P0_07`      | `SDA1_PIN`        |
+| `SCL_PIN`         | `P0_27`      | `SCL1_PIN`        |
+| `LSM_PWR`         | `P1_08`      |                   |
+| `LSM_INT`         | `P0_11`      |                   |
+| `MIC_PWR`         | `P1_10`      |                   |
+| `MIC_CLK`         | `P1_00`      |                   |
+| `MIC_DIN`         | `P0_16`      |                   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Seeed XIAO BLE](../machine/xiao-ble)
+
+## Flashing
+
+### UF2
+
+The XIAO BLE comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Plug your XIAO BLE into your computer's USB port.
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=xiao-ble [PATH TO YOUR PROGRAM]
+    ```
+
+- The XIAO BLE board should restart and then begin running your program.
+
+### Troubleshooting
+
+Add troubleshooting tips here.
+
+## Notes
+
+You can use the USB port to the XIAO BLE as a serial port. `UART0` refers to this connection.
+
diff --git a/content/docs/reference/microcontrollers/xiao-rp2040.md b/content/docs/reference/microcontrollers/xiao-rp2040.md
new file mode 100644
index 00000000..1e2e7e5d
--- /dev/null
+++ b/content/docs/reference/microcontrollers/xiao-rp2040.md
@@ -0,0 +1,71 @@
+---
+title: "Seeed XIAO RP2040"
+weight: 3
+---
+
+The [Seeed XIAO RP2040](https://www.seeedstudio.com/XIAO-RP2040-v1-0-p-5026.html) is a tiny development board based on the Raspberry Pi [RP2040](https://datasheets.raspberrypi.org/rp2040/rp2040-datasheet.pdf) microcontroller.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `D0`              | `GPIO26`     | `A0`, `ADC0`      | `I2C1` (SDA)         | `PWM5` (channel A)   |
+| `D1`              | `GPIO27`     | `A1`, `ADC1`      | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `D2`              | `GPIO28`     | `A2`, `I2C0_SDA_PIN`, `ADC2` |                      | `PWM6` (channel A)   |
+| `D3`              | `GPIO29`     | `A3`, `I2C0_SCL_PIN`, `ADC3` |                      | `PWM6` (channel B)   |
+| `D4`              | `GPIO6`      | `I2C1_SDA_PIN`    | `I2C1` (SDA)         | `PWM3` (channel A)   |
+| `D5`              | `GPIO7`      | `I2C1_SCL_PIN`    | `I2C1` (SCL)         | `PWM3` (channel B)   |
+| `D6`              | `GPIO0`      | `UART0_TX_PIN`, `UART_TX_PIN` | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `D7`              | `GPIO1`      | `UART0_RX_PIN`, `UART_RX_PIN` | `I2C0` (SCL)         | `PWM0` (channel B)   |
+| `D8`              | `GPIO2`      | `SPI0_SCK_PIN`    | `I2C1` (SDA)         | `PWM1` (channel A)   |
+| `D9`              | `GPIO4`      | `SPI0_SDI_PIN`    | `I2C0` (SDA)         | `PWM2` (channel A)   |
+| `D10`             | `GPIO3`      | `SPI0_SDO_PIN`    | `I2C1` (SCL)         | `PWM1` (channel B)   |
+| `NEOPIXEL`        | `GPIO12`     | `WS2812`          | `I2C0` (SDA)         | `PWM6` (channel A)   |
+| `NEO_PWR`         | `GPIO11`     | `NEOPIXEL_POWER`  | `I2C1` (SCL)         | `PWM5` (channel B)   |
+| `LED`             | `GPIO17`     | `LED_RED`         | `I2C0` (SCL)         | `PWM0` (channel B)   |
+| `LED_GREEN`       | `GPIO16`     |                   | `I2C0` (SDA)         | `PWM0` (channel A)   |
+| `LED_BLUE`        | `GPIO25`     |                   |                      | `PWM4` (channel B)   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Seeed XIAO RP2040](../machine/xiao-rp2040)
+
+## Flashing
+
+### UF2
+
+The XIAO RP2040 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=xiao-rp2040 [PATH TO YOUR PROGRAM]
+    ```
+
+- The XIAO RP2040 board should restart and then begin running your program.
+
+### Troubleshooting
+
+Any troubleshooting tips go here.
+
+## Notes
+
+You can use the USB port to the XIAO RP2040 as a serial port.
+
+TinyGo has support for the RP2040's on-board Programmable Input/Output (PIO) block.
+
+For more informantion, see [https://github.com/tinygo-org/pio](https://github.com/tinygo-org/pio)
diff --git a/content/docs/reference/microcontrollers/xiao.md b/content/docs/reference/microcontrollers/xiao.md
new file mode 100644
index 00000000..0622e904
--- /dev/null
+++ b/content/docs/reference/microcontrollers/xiao.md
@@ -0,0 +1,80 @@
+---
+title: "Seeed Studio XIAO SAMD21 aka Seeeduino XIAO"
+weight: 3
+---
+
+The [Seeed Seeeduino XIAO, which has been renamed to Seeed Studio XIAO SAMD21](https://www.seeedstudio.com/Seeeduino-XIAO-Arduino-Microcontroller-SAMD21-Cortex-M0+-p-4426.html) is a tiny ARM development board based on the Atmel [ATSAMD21G18](https://www.microchip.com/wwwproducts/en/ATSAMD21G18) family of SoC.
+
+## Interfaces
+
+| Interface | Hardware Supported | TinyGo Support |
+| --------- | ------------- | ----- |
+| GPIO      | YES | YES |
+| UART      | YES | YES |
+| SPI       | YES | YES |
+| I2C       | YES | YES |
+| ADC       | YES | YES |
+| PWM       | YES | YES |
+| USBDevice | YES | YES |
+
+## Pins
+
+| Pin               | Hardware pin | Alternative names | I2C                  | PWM                  |
+| ----------------- | ------------ | ----------------- | -------------------- | -------------------- |
+| `D0`              | `PA02`       | `A0`              |                      |                      |
+| `D1`              | `PA04`       | `A1`              |                      | `TCC0` (channel 0)   |
+| `D2`              | `PA10`       | `A2`, `I2S_SCK_PIN` |                      | `TCC1` (channel 0), `TCC0` (channel 2) |
+| `D3`              | `PA11`       | `A3`              |                      | `TCC1` (channel 1), `TCC0` (channel 3) |
+| `D4`              | `PA08`       | `A4`, `SDA_PIN`, `I2S_SDO_PIN` | `I2C0` (SDA)         | `TCC0` (channel 0), `TCC1` (channel 2) |
+| `D5`              | `PA09`       | `A5`, `SCL_PIN`   | `I2C0` (SCL)         | `TCC0` (channel 1), `TCC1` (channel 3) |
+| `D6`              | `PB08`       | `A6`, `UART_TX_PIN` |                      |                      |
+| `D7`              | `PB09`       | `A7`, `UART_RX_PIN` |                      |                      |
+| `D8`              | `PA07`       | `A8`, `SPI0_SCK_PIN` |                      | `TCC1` (channel 1)   |
+| `D9`              | `PA05`       | `A9`, `SPI0_SDI_PIN` |                      | `TCC0` (channel 1)   |
+| `D10`             | `PA06`       | `A10`, `SPI0_SDO_PIN` |                      | `TCC1` (channel 0)   |
+| `LED`             | `PA17`       |                   |                      | `TCC2` (channel 1), `TCC0` (channel 3) |
+| `LED_RXL`         | `PA18`       | `LED2`            |                      | `TCC0` (channel 2)   |
+| `LED_TXL`         | `PA19`       | `LED3`            |                      | `TCC0` (channel 3)   |
+| `USBCDC_DM_PIN`   | `PA24`       |                   |                      | `TCC1` (channel 2)   |
+| `USBCDC_DP_PIN`   | `PA25`       |                   |                      | `TCC1` (channel 3)   |
+
+## Machine Package Docs
+
+[Documentation for the machine package for the Seeed Seeeduino XIAO](../machine/xiao)
+
+## Flashing
+
+### UF2
+
+The XIAO comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
+
+### CLI Flashing
+
+- Plug your XIAO into your computer's USB port.
+- Flash your TinyGo program to the board using this command:
+
+    ```shell
+    tinygo flash -target=xiao [PATH TO YOUR PROGRAM]
+    ```
+
+- The XIAO board should restart and then begin running your program.
+
+### Troubleshooting
+
+If you have troubles getting your XIAO board to receive code, try this:
+
+- [Short the "RST pins" two times](https://wiki.seeedstudio.com/Seeeduino-XIAO/#reset) to get the XIAO board ready to receive code.
+- The XIAO board will appear to your computer like a USB drive.
+- Now try running the command as above:
+
+
+```shell
+tinygo flash -target=xiao [PATH TO YOUR PROGRAM]
+```
+
+Once you have updated your XIAO board the first time, after that you should be able to flash it entirely from the command line.
+
+## Notes
+
+You can use the USB port to the XIAO as a serial port. `UART0` refers to this connection.
+
diff --git a/content/usage/_index.md b/content/docs/reference/usage/_index.md
similarity index 76%
rename from content/usage/_index.md
rename to content/docs/reference/usage/_index.md
index d587beae..a6d9ec4c 100644
--- a/content/usage/_index.md
+++ b/content/docs/reference/usage/_index.md
@@ -2,8 +2,8 @@
 title: "Using TinyGo"
 chapter: true
 weight: 2
+description: |
+  How to use the `tinygo` command.
 ---
 
-# Using TinyGo
-
 These pages assume you already have TinyGo installed, either using Docker or by installing it manually.
diff --git a/content/usage/basic.md b/content/docs/reference/usage/basic.md
similarity index 78%
rename from content/usage/basic.md
rename to content/docs/reference/usage/basic.md
index 3f2ed4a8..de1606fe 100644
--- a/content/usage/basic.md
+++ b/content/docs/reference/usage/basic.md
@@ -1,9 +1,10 @@
 ---
 title: "Basic command examples"
 weight: 1
+description: |
+  Here are some basic examples of using TinyGo in the most common scenarios.
 ---
 
-Here will go some basic examples of using TinyGo in the most common scenarios.
 
 ### Building "Hello, World" program for WebAssembly
 
@@ -13,8 +14,7 @@ To build the WASM example, run the following command:
 tinygo build -o wasm.wasm -target=wasm examples/wasm/export
 ```
 
-See the [WebAssembly page](../../webassembly) for more information on executing the compiled
-WebAssembly.
+See the [WebAssembly page](../../../../docs/guides/webassembly) for more information on executing the compiled WebAssembly.
 
 ### Building/flashing a "blink" program for micro:bit
 
@@ -22,7 +22,7 @@ To build and then flash a basic blink program for a micro:bit board:
 
 - Plug your micro:bit into your computer's USB port.
 - The micro:bit board will appear to your computer like a USB drive. Determine the path to the board, for example on Linux it will be something like `/media/[USERNAME]/[NAME OF THE BOARD]`.
-- Run the following command, substituing the correct name for the board from the previous step:
+- Run the following command, substituting the correct name for the board from the previous step:
 
 ```shell
 tinygo build -o=/media/[USERNAME]/[NAME OF THE BOARD]/flash.hex -target=microbit examples/microbit-blink
@@ -35,7 +35,7 @@ The top-left pixel of the built-in LED matrix on the micro:bit board should star
 To build and then flash a basic blink program for an Arduino Uno,
 
 - Plug in the board to your computer's USB port.
-- Run the following command, specifiying the serial port if needed. (It defaults to `/dev/ttyACM0` as that is the default port on Linux.)
+- Run the following command, specifying the serial port if needed. (It defaults to `/dev/ttyACM0` as that is the default port on Linux.)
 
 ```shell
 tinygo flash -target=arduino -port=[PORT] examples/blinky1
@@ -50,7 +50,7 @@ To build and then flash a basic blink program for an Circuit Playground Express,
 - Plug your Circuit Playground Express into your computer's USB port.
 - Press the "RESET" button on the board two times to get the Circuit Playground Express board ready to receive code. If you just received the board, it will be running MakeCode, so press the "RESET" button just once. Either way, the NeoPixel LEDs should turn all green.
 - The Circuit Playground Express board will appear to your computer like a USB drive. Determine the path to the board, for example on Linux it will be something like `/media/[USERNAME]/[NAME OF THE BOARD]`.
-- Run the following command, substituing the correct name for the board from the previous step:
+- Run the following command, substituting the correct name for the board from the previous step:
 
 ```shell
 tinygo build -o=/media/[USERNAME]/[NAME OF THE BOARD]/flash.uf2 -target=circuitplay-express examples/blinky1
diff --git a/content/docs/reference/usage/important-options.md b/content/docs/reference/usage/important-options.md
new file mode 100644
index 00000000..90c19e06
--- /dev/null
+++ b/content/docs/reference/usage/important-options.md
@@ -0,0 +1,95 @@
+---
+title: "Important Build Options"
+weight: 3
+description: |
+  Command line flags you will commonly use with TinyGo that often control how the binary is built or flashed to the device.
+---
+
+There are a few flags to control how binaries are built:
+
+- `-o`
+Output filename, see the ``build`` command.
+
+- `-target`
+    Select the target you want to use. Leave it empty to compile for the host. This switch also configures the emulator, flash tool and debugger to use so you don't have to fiddle with those options. Read [supported targets](../../microcontrollers/) for a list of supported targets. Example targets:
+
+  - `-target=wasm`  
+    WebAssembly target. Creates .wasm files that can be run in a web browser.
+
+  - `-target=arduino`  
+    Compile using the experimental AVR backend to run Go programs on an Arduino Uno.
+
+  - `-target=microbit`  
+    Compile programs for the [BBC micro:bit](https://microbit.org/).
+
+  - `-target=cortex-m-qemu`  
+    Run on a Stellaris LM3S as emulated by QEMU. This is mostly useful for testing.
+
+- `-port`
+Specify the serial port used for flashing. This is used for the Arduino Uno, which is flashed over a serial port. It defaults to ``/dev/ttyACM0`` as that is the default port on Linux.
+
+- `-opt`
+Which optimization level to use. Optimization levels roughly follow standard `-O` level options like ``-O2``, ``-Os``, etc. Available optimization levels:
+
+  - `-opt=0`
+Disable as much optimizations as possible. There are still a few optimization passes that run to make sure the program executes correctly, but all LLVM passes that can be disabled are disabled.
+
+  - `-opt=1`
+Enable only a few optimization passes. In particular, this keeps the inliner disabled. It can be useful when you want to look at the generated IR but want to avoid the noise that is common in non-optimized code.
+
+  - `-opt=2`
+A good optimization level for use cases not strongly limited by code size. Provided here for completeness. It enables most optimizations and will likely result in the fastest code.
+
+  - `-opt=s`
+Like `-opt=2`, but while being more careful about code size. It provides a balance between performance and code size.
+
+  - `-opt=z` (default)
+Like ``-opt=s``, but more aggressive about code size. This pass also reduces the inliner threshold by a large margin. Use this pass if you care a lot about code size.
+
+- `-ocd-output`
+Print output of the on-chip debugger tool (like OpenOCD) while in a `tinygo gdb` session. This can be useful to diagnose connection problems.
+
+- `-gc`
+Use the specified memory manager. The default is usually the best option, so leave this value at the default unless you know what you're doing. The possible values are:
+
+  - `-gc=none`  
+    Do not use a memory manager at all. This will cause a link error at every place in the program that tries to allocate memory. The primary use case for this is finding such locations.
+
+  - `-gc=leaking`  
+    Only allocate memory, never free it. This is the simplest allocator possible and uses very few resources while being very portable. Also, allocation is very fast. Larger programs will likely need a real garbage collector.
+
+  - `-gc=conservative`  
+    Simple conservative mark/sweep garbage collector. This collector works on all platforms. Also, the performance of the collector is highly unpredictable as any allocation may trigger a garbage collection cycle.
+
+- `-panic`
+Use the specified panic strategy. That is, what the compiled program should do when a panic occurs.
+
+  - `-panic=abort`
+    Print the panic message and abort the program. This is the default. On a desktop system this results in a call to [`abort`](https://manpages.debian.org/stretch/manpages-dev/abort.3.en.html). On WebAssembly this is implemented as the [`unreachable`](https://webassembly.github.io/spec/core/syntax/instructions.html#syntax-instr-control) instruction. On microcontrollers, it results in a hang (endless loop).
+
+  - `-panic=trap`
+    Do not print the panic message but instead of printing anything, it directly hits a trap instruction. This instruction varies by platform but it will result in the immediate termination of the program. It could either exit with `SIGILL` or cause a call to the `HardFault_Handler`. It can be used to reduce the size of the compiled program while keeping standard Go safety rules intact at the cost of debuggability.
+
+- `-serial` Use the specified serial output as the default stdout. This applies to various runtime outputs such as `println` and `panic`, but also to `os.Stdout` (and therefore `fmt.Println`).
+
+  The default varies by board, but it's usually `-serial=usb` on many newer boards (those with a rp2040, samd21, samd51, or nrf52 chip). Older boards like the Arduino Uno typically use `-serial=uart`, and very small chips like the attiny1616 will use `-serial=none` to disable serial output entirely.
+
+  To see the output, you can use the `-monitor` flag to `tinygo flash`, or use `tinygo monitor`.
+
+  - `-serial=uart` Use the default UART as set in `machine.DefaultUART`. Which UART this is varies by board, but it's typically the first UART indicated on the silkscreen (with TX/RX markings). You may need an external USB-UART connector to receive output this way.
+
+  - `-serial=usb` Use USB-CDC as the serial transport. This will usually not need any extra cables: chips with USB-CDC support are usually also programmed this way.
+
+  - `-serial=rtt` Use [Segger RTT](https://wiki.segger.com/index.php?title=RTT). This only works if you are connected to the chip using a debug probe (most debug probes will work, not just the one from Segger). There are a few boards with a built-in debugger where it might work out of the box, but in most cases you will need an [external debugger]({{< ref "/docs/guides/debugging" >}}).
+
+  - `-serial=none` Disable serial output entirely. This can be useful if you want to use the default serial output for something else. In some cases, disabling serial output will reduce current consumption and/or reduce binary size.
+
+- `-scheduler`
+Use the specified scheduler. The default scheduler varies by platform. For example, `AVR` currently defaults to `none` because it has such limited memory while `asyncify` and `tasks` are used for other platforms. Normally you do not need to override the default except on AVR where you can optionally select the tasks scheduler if you want concurrency.
+
+  - `scheduler=tasks` The tasks scheduler is a scheduler much like an RTOS available for non-WASM platforms. This is usually the preferred scheduler.
+  - `scheduler=asyncify` The asyncify scheduler is a scheduler for WASM based off of [Binaryen's Asyncify Pass](https://github.com/WebAssembly/binaryen/blob/main/src/passes/Asyncify.cpp).
+  - `scheduler=none` The none scheduler disables scheduler support, which means that goroutines and channels are not available. It can be used to reduce firmware size and RAM consumption if goroutines and channels are not needed.
+
+- `-ldflags`
+The TinyGo `ldflags` flag has the same behavior as the Go link tool `ldflags` flag. It passes a value along to the TinyGo linker. This is commonly used to set the value for a variable at the time that the program is compiled for example `-ldflags="-X 'package_path.variable_name=new_value'"` See [How to set build-time variables]({{< ref "tips-n-tricks.md" >}}) for more information.
diff --git a/content/docs/reference/usage/misc-options.md b/content/docs/reference/usage/misc-options.md
new file mode 100644
index 00000000..90c679b4
--- /dev/null
+++ b/content/docs/reference/usage/misc-options.md
@@ -0,0 +1,40 @@
+---
+title: "Misc. Build Options"
+weight: 4
+description: |
+  Command line flags that are less commonly used and don't usually impact the build.
+---
+
+- `-no-debug`
+Disable outputting debug symbols. This can be useful for WebAssembly, as there is no debugger for .wasm files yet and .wasm files are generally served directly. Avoiding debug symbols can have a big impact on generated binary size, reducing them by more than half.
+This is not necessary on microcontrollers because debugging symbols are not flashed to the microcontroller. Additionally, you will need it when you use `tinygo gdb`. In general, it is recommended to include debug symbols unless you have a good reason not to.
+Note: while there is some support for debug symbols, only line numbers have been implemented so far. That means single-stepping and stacktraces work just fine, but no variables can be inspected.
+
+- `-size`
+    Print size (``none``, ``short``, or ``full``) of the output (linked) binary. Note that the calculated size includes RAM reserved for the stack.
+
+    - `none` (default)
+        Print nothing.
+    
+    - `short`
+        Print size statistics, roughly like what the ``size`` binutils program would print but with useful flash and RAM columns:
+        ```
+        code    data     bss |   flash     ram
+        5780     144    2132 |    5924    2276
+        ```
+    
+    - `full`
+        Try to determine per package how much space is used. Note that these calculations are merely guesses and can sometimes be way off due to various reasons like inlining:
+        ```
+        code  rodata    data     bss |   flash     ram | package
+        876        0       4       0 |     880       4 | (bootstrap)
+        38         0       0       0 |      38       0 | device/arm
+        0          0       0      66 |       0      66 | machine
+        2994     440     124       0 |    3558     124 | main
+        948      127       4       1 |    1079       5 | runtime
+        4856     567     132      67 |    5555     199 | (sum)
+        5780       -     144    2132 |    5924    2276 | (all)
+        ```
+
+- `-print-allocs=<regex>`
+    Print heap allocations in the program and why they happen. You can use `-print-allocs=.` if you want to see all heap allocations in the program. You can also match the function name, for example you can use `-print-allocs=strconv` to print heap allocations that contain the `strconv` substring (which includes all functions from the strconv standard library package).
diff --git a/content/docs/reference/usage/subcommands.md b/content/docs/reference/usage/subcommands.md
new file mode 100644
index 00000000..08dffc47
--- /dev/null
+++ b/content/docs/reference/usage/subcommands.md
@@ -0,0 +1,105 @@
+---
+title: "Subcommands"
+weight: 2
+description: |
+  Subcommands like `tinygo flash` and `tinygo version`.
+---
+
+TinyGo tries to be similar to the main `go` command in usage. It consists of the following main subcommands:
+
+### build
+Build compiles the package named by the import path, along with its dependencies, but it does not install the result.
+The generated file type depends on the extension:
+
+`.o`
+Create a relocatable object file. You can use this option if you don't want to use the TinyGo build system or want to do other custom things.
+
+`.ll`
+Create textual LLVM IR, after optimization. This is mainly useful for debugging.
+
+`.bc`
+Create LLVM bitcode, after optimization. This may be useful for debugging or for linking into other programs using LTO.
+
+`.hex`
+Create an [Intel HEX](https://en.wikipedia.org/wiki/Intel_HEX) file to flash it to a microcontroller.
+
+`.bin`
+Similar, but create a binary file.
+
+`.wasm`
+Compile and link a WebAssembly file.
+
+(all other)
+Compile and link the program into a regular executable. For microcontrollers, it is common to use the .elf file extension to indicate a linked ELF file is generated. For Linux, it is common to build binaries with no extension at all.
+
+### run
+Run the program, either directly on the host or in an emulated environment (depending on `-target`).
+
+### flash
+Flash the program to a microcontroller. Some common flags are described below.
+
+`-target={name}`: Specifies the type of microcontroller that is used. The `name`
+of the microcontroller is given on the individual pages for each board type
+listed under [Microcontrollers]({{<ref "../microcontrollers/">}}). For example,
+`arduino-nano`, `d1mini`, `xiao`.
+
+`-monitor`: Start the serial monitor (see below) immediately after flashing.
+However, some microcontrollers need a split second or two to configure the
+serial port after flashing, and using the `-monitor` flag can fail because the
+serial monitor starts too quickly. In that case, use the `tinygo monitor`
+command explicitly.
+
+### monitor
+Start the serial monitor on the serial port that is connected to the
+microcontroller. If there is only a single board attached to the host computer,
+the default values for various options should be sufficient. In other
+situations, particularly if you have multiple microcontrollers attached, some
+parameters may need to be overridden using the following flags:
+
+`-port={port}`: If there are multiple microcontroller attached, an error message
+will display a list of potential serial ports. The appropriate port can be
+specified by this flag. On Linux, the port will be something like `/dev/ttyUSB0`
+or `/dev/ttyACM1`. On MacOS, the port will look like `/dev/cu.usbserial-1420`.
+On Windows, the port will be something like `COM1` or `COM31`.
+
+`-baudrate={rate}`: The default baud rate is 115200. Boards using the AVR
+processor (e.g. [Arduino Nano]({{<ref "../microcontrollers/arduino-nano.md">}}),
+[Arduino Mega 2560]({{<ref "../microcontrollers/arduino-mega2560">}})) use 9600
+instead.
+
+`-target={name}`: If you have more than one microcontrollers attached, you can
+sometimes just specify the target name and let `tinygo monitor` figure out the
+port. Sometimes, this does not work and you have to explicitly use the `-port`
+flag.
+
+The serial monitor intercepts several control characters for its own use instead
+of sending them to the microcontroller:
+
+* Control-C: terminates the `tinygo monitor`
+* Control-Z: suspends the `tinygo monitor` and drops back into shell
+* Control-\\: terminates the `tinygo monitor` with a stack trace
+* Control-S: flow control, suspends output to the console
+* Control-Q: flow control, resumes output to the console
+* Control-@: thrown away by `tinygo monitor`
+
+**Note**: If you are using `os.Stdin` on the microcontroller, you may find that
+a CR character on the host computer (also known as Enter, `^M`, or `\r`) is
+transmitted to the microcontroller without conversion, so `os.Stdin` returns a
+`\r` character instead of the expected `\n` (also known as `^J`, NL, or LF) to
+indicate end-of-line. You may be able to get around this problem by hitting
+`Control-J` in `tinygo monitor` to transmit the `\n` end-of-line character.
+
+### gdb
+Compile the program, optionally flash it to a microcontroller if it is a remote target, and drop into a GDB shell. From there you can set breakpoints, start the program with `run` or `continue` (`run` for a local program, `continue` for on-chip debugging), single-step, show a backtrace, break and resume the program with Ctrl-C/`continue`, etc. You may need to install extra tools (like `openocd` and `arm-none-eabi-gdb`) to be able to do this. Also, you may need a dedicated debugger to be able to debug certain boards if no debugger is integrated. Some boards (like the BBC micro:bit and most professional evaluation boards) have an integrated debugger.
+
+### clean
+Clean the cache directory, normally stored in `$HOME/.cache/tinygo`. This is not normally needed.
+
+### help
+Print a short summary of the available commands, plus a list of command flags.
+
+### version
+Print the version of the command and the version of the used `$GOROOT`.
+
+### env
+Print a list of environment variables that affect TinyGo (as a shell script). If one or more variable names are given as arguments, env prints the value of each on a new line.
diff --git a/content/docs/tutorials/_index.md b/content/docs/tutorials/_index.md
new file mode 100644
index 00000000..9bf0f437
--- /dev/null
+++ b/content/docs/tutorials/_index.md
@@ -0,0 +1,6 @@
+---
+title: "Tutorials"
+weight: 1
+description: >
+  These step-by-step tutorials introduce you to new concepts by doing.
+---
diff --git a/content/docs/tutorials/blinky.md b/content/docs/tutorials/blinky.md
new file mode 100644
index 00000000..81d93224
--- /dev/null
+++ b/content/docs/tutorials/blinky.md
@@ -0,0 +1,135 @@
+---
+title: "Blinking LED"
+weight: 1
+---
+
+After you've [installed TinyGo]({{<ref "install">}}), you can now start using it! We're going to blink an LED. A blinking LED is like the [hello world](https://en.wikipedia.org/wiki/%22Hello,_World!%22_program) of hardware: it is the smallest piece of code that shows the hardware is working.
+
+For this tutorial, previous experience with Go is not required but recommended.
+
+You will need a board with an onboard LED. Most education and development boards will work, with the notable exception of the BBC micro:bit. Boards that are a good start are one of the following:
+
+  - [Adafruit Circuit Playground Express](../../reference/microcontrollers/circuitplay-express/)
+  - [Arduino Nano 33 IoT](../../reference/microcontrollers/arduino-nano33/)
+
+Now that you have a board, let's get started. Start by creating a new directory (for example, named blink) and navigating into it. If you are using Go modules, initialize a new module with the following command:
+
+    go mod init blinky
+
+Next, create a new file named main.go with the following contents:
+
+```go
+package main
+
+import (
+    "machine"
+    "time"
+)
+
+func main() {
+    led := machine.LED
+    led.Configure(machine.PinConfig{Mode: machine.PinOutput})
+    for {
+        led.Low()
+        time.Sleep(time.Millisecond * 500)
+
+        led.High()
+        time.Sleep(time.Millisecond * 500)
+    }
+}
+```
+
+As you can see, it has a main function (the entrypoint of the program) that configures a LED as an output and then in a loop sets the LED to low or high while sleeping for 500 milliseconds in between. We'll explain this more in-depth [later in this tutorial](#background), first let's run this on the microcontroller.
+
+To transfer this program to the board, we'll use the `flash` subcommand. Flashing is the term used for writing a program to a microcontroller. You can do it by `cd`'ing to the directory and running this command:
+
+    tinygo flash -target=circuitplay-express
+
+A few seconds later, the program should be written to the board and an LED should start to blink. If it works, congratulations! You're running your first Go program on a microcontroller.
+
+If you are using a different board, you need to replace the `-target` flag. For example, the [Arduino Uno](../../reference/microcontrollers/arduino-uno/) requires `-target=arduino` and an [Adafruit ItsyBitsy M4](../../reference/microcontrollers/itsybitsy-m4/) requires `-target=itsybitsy-m4`. You can get the full list by going to [Go on microcontrollers](../../reference/microcontrollers/), picking the board on the left and looking under the "Flashing" section.
+
+## Background
+
+So what's really happening here? We'll go through this line by line.
+
+```go
+package main
+```
+
+Every Go file starts with a `package` line. A Go package is a collection of Go files in a single directory. In this case we only have a single file but most packages will have multiple files.
+
+This package is named main, which is a bit special. It contains the main function, which is the function that will be run when the program starts after initialization.
+
+```go
+import (
+    "machine"
+    "time"
+)
+```
+
+For this small program we need two packages, which are a kind of libraries:
+
+ 1. The machine package, which provides direct access to the hardware in a somewhat portable way. For example, it allows controlling GPIO pins.
+ 2. The time package, which - you guessed - handles time. You can get the current time with `time.Now()` and sleep for a while with `time.Sleep(duration)`. It also provides some extra utilities such as parsing and formatting time and stuff like time zone handling.
+
+Of these, only the time package is standard Go. The machine package was invented by the TinyGo project.
+
+```go
+func main() {
+```
+
+This main function is special: like the `main` function in C or `public static void main` in Java, this is the first function that will run. Returning from here will exit the program. It doesn't make sense to "exit" from a microcontroller, so you should avoid returning from it in TinyGo.
+
+```go
+led := machine.LED
+```
+
+This declares a new variable named `led`. If you are not familiar with Go, the `:=` operator is somewhat like `auto` in C++: it declares a new variable while inferencing the type from the right hand size. In this case, this is the `machine.LED` constant which has type `machine.Pin`.
+
+
+```go
+led.Configure(machine.PinConfig{Mode: machine.PinOutput})
+```
+
+This code configures the GPIO pin. Like most peripherals in the machine package, GPIO pins need initialization before they can be used. Maybe the following is clearer if you're not used to this syntax:
+
+```go
+config := machine.PinConfig{
+    Mode: machine.PinOutput
+}
+led.Configure(config)
+```
+
+The first three lines define a new `machine.PinConfig` object and sets the `Mode` field to `machine.PinOutput`. This means that `config.Mode` will now equal `machine.PinOutput`.
+
+
+```go
+for {
+    // ...
+}
+```
+
+This defines an endless for loop. Go does not have a `while` keyword, instead it has a `for` keyword with zero, one, or three operands. Zero operands means that it is an infinite loop, similar to the Rust `loop { ... }` syntax.
+
+```go
+led.Low()
+```
+
+This sets the GPIO output to low, meaning ground (0V). Depending on the wiring, it might turn the LED either on or off.
+
+```go
+time.Sleep(time.Millisecond * 500)
+```
+
+As expected, this sleeps for 500 milliseconds. That doesn't mean nothing is happening: goroutines and interrupts mean that there can be plenty of activity in these 500 milliseconds. But you don't need to worry about that right now.
+
+```go
+led.High()
+```
+
+This changes the LED state. If it was on before, it will now be off. Otherwise, it will now be on. What is certain is that it will start blinking.
+
+## Conclusion
+
+That's it, your first TinyGo program! I hope this tutorial was helpful. If you have any questions, feel free to join the #tinygo channel on the [Gophers Slack](https://invite.slack.golangbridge.org/).
diff --git a/content/docs/tutorials/gdb.md b/content/docs/tutorials/gdb.md
new file mode 100644
index 00000000..37de8fa3
--- /dev/null
+++ b/content/docs/tutorials/gdb.md
@@ -0,0 +1,119 @@
+---
+title: "GDB"
+weight: 10
+description: |
+  Short introduction into debugging with GDB.
+---
+
+The debugger used by TinyGo is called [GDB](https://www.gnu.org/software/gdb/). This tutorial assumes you already have GDB installed and know how to enter the GDB shell, but don't know how to use it yet to actually debug something. For information on how to install and access GDB, see [the debugging guide]({{<ref "debugging.md">}}).
+
+For this tutorial we will assume the following:
+
+  * You have a BBC micro:bit.
+  * You have installed the required software: `openocd` and GDB (either `gdb-multiarch` or `arm-none-eabi-gdb`).
+
+## Enter GDB
+
+Now you can enter the GDB shell using the following command:
+
+```
+$ tinygo gdb -target=microbit examples/microbit-blink
+[...]
+target halted due to debug-request, current mode: Thread 
+xPSR: 0xc1000000 pc: 0x0000071c msp: 0x20000800
+(gdb) 
+```
+
+The following line is important:
+
+```
+target halted due to debug-request, current mode: Thread 
+```
+
+It means the target (in this case, the nrf51822 chip on the BBC micro:bit) is paused right at the start of the program.
+
+## Pause and continue
+
+You can start to run it by running the `c` or `continue` command:
+
+```
+(gdb) continue
+Continuing.
+```
+
+Now you should see that the LED on the BBC micro:bit starts to blink, which indicates that it is running.
+
+Pausing the program is done using Ctrl-C. It doesn't stop like you might expect, it only pauses:
+
+```
+(gdb) continue
+Continuing.
+^C
+Program received signal SIGINT, Interrupt.
+0x0000085c in runtime.waitForEvents () at /home/ayke/src/github.com/tinygo-org/tinygo/src/runtime/runtime_nrf_bare.go:8
+8		arm.Asm("wfe")
+(gdb) 
+```
+
+You can see here that the program pauses at the `wfe` instruction, the "wait for event" instruction that is executed to suspend the microcontroller. This is because the blinking LED example spends the vast majority of its time sleeping, and to reduce power consumption it enters a low power state using this instruction.
+
+You can also see that the LED stopped blinking: the processor was paused by the debug probe.
+
+## Backtrace
+
+One very useful command is `backtrace` or `bt`:
+
+```
+(gdb) bt
+#0  0x0000085c in runtime.waitForEvents () at /home/ayke/src/github.com/tinygo-org/tinygo/src/runtime/runtime_nrf_bare.go:8
+#1  runtime.rtc_sleep (ticks=<optimized out>) at /home/ayke/src/github.com/tinygo-org/tinygo/src/runtime/runtime_nrf.go:135
+#2  runtime.sleepTicks (d=16383) at /home/ayke/src/github.com/tinygo-org/tinygo/src/runtime/runtime_nrf.go:73
+#3  runtime.scheduler () at /home/ayke/src/github.com/tinygo-org/tinygo/src/runtime/scheduler.go:158
+#4  runtime.run () at /home/ayke/src/github.com/tinygo-org/tinygo/src/runtime/scheduler_any.go:24
+#5  Reset_Handler () at /home/ayke/src/github.com/tinygo-org/tinygo/src/runtime/runtime_nrf.go:27
+(gdb) 
+```
+
+You can see that the program was somewhere in the scheduler and not in a goroutine.
+
+## Breakpoints
+
+One of the main features of GDB is setting breakpoints. For example, let's say we want to break on printing a string. For that, we can break on the `runtime.printstring` function using the `b` or `break` command:
+
+```
+~$ tinygo gdb -target=microbit examples/serial
+[...]
+target halted due to debug-request, current mode: Thread 
+xPSR: 0xc1000000 pc: 0x0000071c msp: 0x20000800
+(gdb) b runtime.printstring
+Breakpoint 1 at 0x19c: file /home/ayke/src/github.com/tinygo-org/tinygo/src/runtime/print.go, line 14.
+(gdb) c
+Continuing.
+Note: automatically using hardware breakpoints for read-only addresses.
+
+Breakpoint 1, runtime.printstring (s=...) at /home/ayke/src/github.com/tinygo-org/tinygo/src/runtime/print.go:14
+14			putchar(s[i])
+(gdb) bt
+#0  runtime.printstring (s=...) at /home/ayke/src/github.com/tinygo-org/tinygo/src/runtime/print.go:14
+#1  0x0000096e in main.main () at /home/ayke/src/github.com/tinygo-org/tinygo/src/examples/serial/serial.go:7
+(gdb) list
+9	}
+10	
+11	//go:nobounds
+12	func printstring(s string) {
+13		for i := 0; i < len(s); i++ {
+14			putchar(s[i])
+15		}
+16	}
+17	
+18	func printuint8(n uint8) {
+(gdb) 
+```
+
+Here, you can see the following commands:
+
+ 1. `b runtime.printstring` to set a breakpoint on the `printstring` function in the runtime package.
+ 2. `c` to start running the program (it was paused).
+ 3. The program hits the breakpoint almost immediately.
+ 4. `bt` shows the backtrace, which stops at the `main.main` function because that's the root function of the goroutine.
+ 5. `list` shows the code around the breakpoint.
diff --git a/content/docs/tutorials/pwm.md b/content/docs/tutorials/pwm.md
new file mode 100644
index 00000000..af050b71
--- /dev/null
+++ b/content/docs/tutorials/pwm.md
@@ -0,0 +1,155 @@
+---
+title: "Using PWM"
+weight: 2
+---
+
+If you've gone through the [blinky](../blinky) example and want to take it to the next level with [PWM](https://en.wikipedia.org/wiki/Pulse-width_modulation), or **Pulse-Width Modulation**, this is the tutorial for you. PWM allows for control of most [servos](https://en.wikipedia.org/wiki/Servomotor) and LED intensity. We'll be trying out the latter here.
+
+**Requirements**
+* Go tool. Get it at [golang.org](https://golang.org/)
+* TinyGo tool. Here's the [quick install guide](/getting-started/install/)
+* A microcontroller with an on-board LED and PWM peripheral such as the [Raspberry Pi Pico](https://www.raspberrypi.org/products/raspberry-pi-pico/) (MSRP $4 USD)
+
+Let's create a directory anywhere on your computer and navigate to it with the terminal. Run the following command in the directory:
+
+```shell
+go mod init pwm-blinky
+```
+
+Next, create a new file named main.go with the following contents:
+
+```go
+package main
+
+import (
+	"machine"
+	"time"
+)
+
+var period uint64 = 1e9 / 500
+
+func main() {
+    // This program is specific to the Raspberry Pi Pico.
+    pin := machine.LED
+	pwm := machine.PWM4 // Pin 25 (LED on pico) corresponds to PWM4.
+
+	// Configure the PWM with the given period.
+	pwm.Configure(machine.PWMConfig{
+		Period: period,
+	})
+
+	ch, err := pwm.Channel(pin)
+	if err != nil {
+		println(err.Error())
+		return
+	}
+
+	for { 
+		for i := 1; i < 255; i++ {
+            // This performs a stylish fade-out blink
+			pwm.Set(ch, pwm.Top()/uint32(i))
+			time.Sleep(time.Millisecond * 5)
+		}
+	}
+}
+```
+
+There's quite a bit to unpack in the program above and there are some notable differences between the blinky example. The main take-away here is the two parts to the program: first we setup the PWM peripheral which corresponds to the LED pin, lastly we enter an infinite for loop which blinks the LED with variable intensity given by `pwm.Set` method.
+
+To transfer this program to the board, we'll use the `flash` subcommand. Flashing is the term used for writing a program to a microcontroller. You can do it by `cd`'ing to the directory and running this command:
+
+    tinygo flash -target=pico
+
+Wait a few seconds and the LED should start to blink with a fade-out effect. This effect can be changed by changing the second argument to `pwm.Set`.
+
+## Explanation
+
+So let's take a deeper look, how does PWM work behind the curtains? We'll go through the program line by line.
+
+The first ~10 or so lines are the package declaration and imports, those are explained in finer detail in the [blinky](../blinky) example.
+
+Our logic for the program lies entirely within the `main` function. This is where the magic happens.
+
+```go
+led := machine.LED
+```
+This declares a new variable named `led`. If you are not familiar with Go, the `:=` operator is somewhat like `auto` in C++: it declares a new variable while inferencing the type from the right hand size. In this case, this is the `machine.LED` constant which has type `machine.Pin`. Boards which have an on-board LED will have this constant available for use.
+
+```go
+pwm := machine.PWM4
+```
+Now things start to look quite different to the blinky example. This code creates a variable which references a PWM peripheral. 
+
+If you don't know which PWM peripheral to use for a pin, you can look it up in the documentation for your board. For example, for the [Raspberry Pi Pico](../../reference/microcontrollers/pico/) you can find a table with pins:
+
+| Pin               | Hardware pin | PWM                  |
+| ----------------- | ------------ | -------------------- |
+| `LED`             | `GPIO25`     | `PWM4` (channel B)   |
+
+Here, you can see the LED pin can be controlled by `PWM4`. (The table is a lot larger than this, but this is the relevant part).
+
+A _peripheral_ refers to any on-chip piece of hardware that runs independently of the CPU core but which interfaces directly with the CPU. They are used for things that are difficult or impossible to do in software. Some other tasks which different peripherals may manage are communications ([I2C](https://en.wikipedia.org/wiki/I%C2%B2C), [SPI](https://en.wikipedia.org/wiki/Serial_Peripheral_Interface), UART, etc.) and [ADC](https://en.wikipedia.org/wiki/Analog-to-digital_converter)/[DAC](https://en.wikipedia.org/wiki/Digital-to-analog_converter).
+
+In the case of a PWM peripheral, there is the additional idea of a channel which can be used to control more than one pin at the same time with a single PWM peripheral. All channels of a PWM peripheral have the same period (or frequency), but they can have a different duty cycle (or "on" time).
+
+```go
+var period uint64 = 1e9 / 500
+```
+We previously declared a new variable to calculate and store the PWM period of 2 milliseconds. By convention periods are unsigned integers which represent a duration in _nanoseconds_, also written as _ns_. The formula used above is `period = 1 / frequency`, where `500` is the desired frequency in hertz (periods per second) and `1e9` is a conversion constant to convert a period in seconds to nanoseconds. 
+
+The period of a PWM signal is the time between rising edges.
+
+```go
+pwm.Configure(machine.PWMConfig{Period: period})
+```
+This code configures the PWM peripheral with the desired period. Keep in mind the output period of the PWM is usually not exact and may differ between microcontrollers.
+
+```go
+ch, err := pwm.Channel(pin)
+```
+This code obtains the channel of the peripheral corresponding to the `pin` we want output on.
+
+```go
+for { 
+    // ... 
+}
+```
+This code defines an endless `for` loop. All of it's contents are run on repeat forever. This can usually be found as "`while true`" in other languages.
+
+```go
+for i := 1; i < 255; i++ {
+    // ...
+}
+```
+This defines a loop which:
+* declares and initializes the variable `i` to `1` (`i := 1`)
+* Loops until `i` is equal to 255 or greater (`i < 255`)
+* Adds `1` to `i` after each loop (`i++`)
+
+
+```go
+pwm.Set(ch, pwm.Top()/uint32(i))
+```
+The `Set` method sets the [duty cycle](https://en.wikipedia.org/wiki/Duty_cycle) of the PWM. We must pass in the channel `ch` we obtained earlier which sets the PWM on the desired pin.
+
+The second argument to `Set` is the **threshold**, which is expressed as a part of the PWM's `top` value. There are various details to how PWM works at the lowest detail, to put it simply:
+
+_PWM works by having a counter (like the variable `i` mentioned above) which decides if the pin is "off" or "on". If this counter is above the **threshold** then the pin is "off", if it is below the threshold it is "on". The counter is incremented automatically continuously until it reaches the **top** value, when the counter reaches top, it is reset to 0. The fraction of time the pin is "on" vs. "off" is called the **duty cycle**._ 
+
+
+```go
+pwm.Top()/uint32(i)
+```
+By using the above expression we are setting the threshold at a value between `top` and `top/255`, where `threshold=top` is a 100% dutycycle (always on) and `threshold=top/255` is 1/255% dutycycle, or 0.4% (practically off).
+
+
+```go
+time.Sleep(time.Millisecond * 5)
+```
+This code stops the program for 5 milliseconds and does nothing for that duration. It is used to slow down the rate at which the LED blinks. If it were not present then we would not notice the fade out effect because it would happen too fast to be perceived!
+
+## Final thoughts
+
+Although PWM may have its ups and downs which make it a complex topic to explain thoroughly, the program shown has everything one needs to begin harnessing the power of PWM control.
+
+I hope this tutorial was helpful. If you have any questions, feel free to join the #tinygo channel on the [Gophers Slack](https://invite.slack.golangbridge.org/).
diff --git a/content/docs/tutorials/serialmonitor.md b/content/docs/tutorials/serialmonitor.md
new file mode 100644
index 00000000..abdd46fb
--- /dev/null
+++ b/content/docs/tutorials/serialmonitor.md
@@ -0,0 +1,414 @@
+---
+title: "Serial Monitor"
+weight: 3
+description: |
+  How to write to and read from the serial port.
+---
+
+When you run a Go program on a desktop computer, you can use the `fmt.Print()`,
+`fmt.Println()`, and `fmt.Printf()` functions from the Go standard [fmt
+package](https://pkg.go.dev/fmt) to print strings and numbers to the terminal
+program on the desktop computer. The Go language also supports the low-level
+[print() and println()](https://go.dev/ref/spec#Bootstrapping) built-in
+functions to print to the terminal.
+
+A TinyGo program running on a microcontroller can use those same functions to
+print strings and numbers to its serial monitor port and have them appear on the
+terminal program on the host computer. By default, the `fmt` functions and the
+`print()/println()` functions are configured to send to the `machine.Serial`
+object of the microcontroller.
+
+On some microcontrollers, the `machine.Serial` object is configured to send to
+the
+[UART](https://en.wikipedia.org/wiki/Universal_asynchronous_receiver-transmitter)
+chip, which is often wired to a [USB-to-serial
+adapter](https://en.wikipedia.org/wiki/USB-to-serial_adapter) chip on the dev
+board. The adapter chip converts the serial bits into USB packets to the host
+computer. On other microcontrollers, the USB controller is built directly into
+the [microcontroller SoC](https://en.wikipedia.org/wiki/System_on_a_chip). The
+`machine.Serial` object on these microcontrollers is configured to send to the
+USB bus directly, instead of going through a USB-to-serial adapter.
+
+In the context of this tutorial, it does not matter whether the microcontroller
+uses a UART controller or a USB controller. In both cases, the microcontroller
+will appear as a serial device on the host computer which can communicate via
+applications that read from and write to the serial port on the host computer.
+
+## Serial Output
+
+### Using `fmt.Print()` and `fmt.Println()`
+
+Here is a sample program that writes a line every second to the `machine.Serial`
+port:
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+)
+
+func main() {
+    count := 0
+    for {
+        fmt.Println(count, ": Hello, World")
+        time.Sleep(time.Millisecond * 1000)
+        count++
+    }
+}
+```
+
+This can be flashed to the microcontroller using the `tinygo flash` command
+described in the [Blinky tutorial]({{<ref "blinky">}}).
+
+### Using `print()` and `println()`
+
+One problem with the above program is that `fmt` is a large package that
+consumes substantial amount of flash memory on a microcontroller. The built-in
+functions `print()` and `println()` consume far less resources. The above
+program can be written like this:
+
+```go
+package main
+
+import (
+    "time"
+)
+
+func main() {
+    count := 0
+    for {
+        println(count, ": Hello, World")
+        time.Sleep(time.Millisecond * 1000)
+        count++
+    }
+}
+```
+
+An estimate of the flash memory consumption can be printed by the TinyGo
+compiler using the [-size]({{<ref "../reference/usage/misc-options">}}) flag.
+Here is a table that shows the 2 versions of the program above for some
+microcontrollers that I have readily available:
+
+```
++-----------------+---------------+-----------+
+| Board Type      | fmt.Println() | println() |
++-----------------+---------------+-----------+
+| Arduino Zero    | 43532         | 7328      |
+| Seeeduino Xiao  | 43532         | 7388      |
+| STM32 BluePill  | 41756         | 6296      |
+| ESP8266 D1 Mini | 44961         | 3588      |
+| ESP32           | 42410         | 3335      |
++-----------------+---------------+-----------+
+```
+
+The `fmt` package increases flash memory consumption by 35 kB to 40 kB. On some
+microcontrollers with limited amount of flash memory, (e.g. the STM32 Blue Pill
+with 64 kB of flash, the Arduino Zero or Seeeduino Xiao both with 256 kB of
+flash), it may be worth avoiding the overhead of the `fmt` package by using the
+built-in `print()` and `println()` instead.
+
+## Serial Monitor on Host Computer
+
+To see the output of the serial port from the microcontroller, we need to run a
+serial monitor application on the host computer. There are many ways to do this,
+but the easiest is probably the `tinygo monitor` subcommand which is built
+directly into the `tinygo` program itself.
+
+### `monitor` subcommand
+
+After flashing the program above, run the `tinygo monitor` program to see the
+output every second from the microcontroller:
+
+```
+$ tinygo monitor
+Connected to /dev/ttyACM0. Press Ctrl-C to exit.
+4 : Hello, World
+5 : Hello, World
+[...]
+```
+
+In this example, the serial monitor missed the first 4 lines of "Hello, World"
+(0 to 3) because the program started to print those lines immediately after
+flashing, but before the serial monitor was connected.
+
+### `-monitor` flag
+
+It is often useful to automatically start the monitor immediately after flashing
+your program to the microcontroller. The `tinygo flash` command takes an
+optional `-monitor` flag to accomplish this:
+
+```
+$ tinygo flash -target=xiao -monitor
+```
+
+On some microcontrollers, the `-monitor` flag fails with the following error
+message because the monitor starts too quickly:
+
+```
+$ tinygo flash -target=arduino-zero -monitor
+[...]
+Connected to /dev/ttyACM0. Press Ctrl-C to exit.
+error: read error: Port has been closed
+```
+
+If this happens, you can chain the `flash` and `monitor` subcommands manually,
+with a 1 or 2-second delay between the two commands. On Linux or MacOS, the
+command invocation looks like this:
+
+```
+$ tinygo flash -target=arduino-zero && sleep 1 && tinygo monitor
+```
+
+(The `&&` separator runs the next command only if the previous command completed
+without errors. This is safer than using the semicolon `;` separator because the
+semicolon continues to execute commands even if the previous command returned an
+error code.)
+
+### Baud Rate
+
+The default [baud rate](https://en.wikipedia.org/wiki/Serial_port#Speed) of the
+serial port for almost all microcontrollers supported by TinyGo is 115200. The
+exceptions are boards using the AVR processors ([Arduino Nano]({{<ref
+"../reference/microcontrollers/arduino-nano">}}), [Arduino Mega 1280]({{<ref
+"../reference/microcontrollers/arduino-mega1280">}}), [Arduino Mega 2560]({{<ref
+"../reference/microcontrollers/arduino-mega2560">}})). On these, the serial port
+is set to 9600, so you need to override the baud rate of `tinygo monitor` like
+this:
+
+```
+$ tinygo monitor -baudrate=9600
+```
+
+You can combine the `flash` subcommand, the `-monitor` flag, and the `-baudrate`
+flag into a single invocation like this:
+
+```
+$ tinygo flash -target arduino-nano -monitor -baudrate 9600
+```
+
+(Notice that the `=` after each flag has been replaced with a space. It's an
+alternative syntax that some people prefer because a space is easier to type
+than an equal sign `=`.)
+
+### Serial Port on Host
+
+The microcontroller will be assigned a serial port on the host computer. If you
+have only a single microcontroller attached, you will normally not need to worry
+about what these serial ports are called. The `tinygo monitor` will
+automatically figure out which serial port to use.
+
+On Linux machines, the serial port will have a `USB` prefix or an `ACM` prefix
+like this:
+
+* `/dev/ttyUSB0`
+* `/dev/ttyACM0`
+
+On MacOS machines, the serial port will look like this:
+
+* `/dev/cu.usbserial-1420`
+* `/dev/cu.usbmodem6D8733AC53571`
+
+On Windows machines, the serial port looks something like:
+
+* `COM1`
+* `COM31`
+
+### Multiple Microcontrollers
+
+If you have more than one microcontroller attached to the host computer, the
+`tinygo flash` and `tinygo monitor` subcommands can *sometimes* figure out which
+port it is using, but they will sometimes print out an error message, like this:
+
+```
+$ tinygo flash -target arduino-nano
+error: multiple serial ports available - use -port flag,
+available ports are /dev/ttyACM0, /dev/ttyUSB0
+```
+
+You then need to supply the `-port` flag to identify the microcontroller that
+you want to flash and monitor:
+
+```
+$ tinygo flash -target=arduino-nano -port=/dev/ttyUSB0
+
+$ tinygo monitor -port=/dev/ttyUSB0 -baudrate=9600
+```
+
+Sometimes it is possible to combine the two commands into a single command even
+in the presence of multiple microcontrollers:
+
+```
+$ tinygo flash -target xiao -monitor
+```
+
+But sometimes, combining `flash` and `monitor` into a single command does not
+work. In that case, you can issue the `flash` and `monitor` commands separately.
+But it is often easier to just pull out the extra microcontroller(s) so that
+only a single board is connected to the host computer.
+
+```
+$ tinygo flash -target=arduino-nano -monitor
+error: multiple serial ports available - use -port flag,
+available ports are /dev/ttyACM0, /dev/ttyUSB0
+
+$ tinygo flash -target=arduino-nano -monitor -port=/dev/ttyUSB0 -baudrate=9600
+[...]
+avrdude: 4238 bytes of flash verified
+avrdude done.  Thank you.
+[...]
+error: multiple serial ports available - use -port flag,
+available ports are /dev/ttyACM0, /dev/ttyUSB0
+```
+
+## Serial Input
+
+Occasionally it is useful to send characters from the host computer to the
+microcontroller. The following program reads a single byte from the
+`machine.Serial` object and prints the character back to the host computer.
+
+The caveat is that the `Serial.ReadByte()` feature is *not* currently
+implemented on every microcontroller supported by TinyGo. For example, the
+following program does not work on the ESP32 or the ESP8266.
+
+```go
+package main
+
+import (
+    "machine"
+    "time"
+)
+
+func main() {
+    time.Sleep(time.Millisecond * 2000)
+    println("Reading from the serial port...")
+
+    for {
+        c, err := machine.Serial.ReadByte()
+        if err == nil {
+            if c < 32 {
+                // Convert nonprintable control characters to
+                // ^A, ^B, etc.
+                machine.Serial.WriteByte('^')
+                machine.Serial.WriteByte(c + '@')
+            } else if c >= 127 {
+                // Anything equal or above ASCII 127, print ^?.
+                machine.Serial.WriteByte('^')
+                machine.Serial.WriteByte('?')
+            } else {
+                // Echo the printable character back to the
+                // host computer.
+                machine.Serial.WriteByte(c)
+            }
+        }
+
+        // This assumes that the input is coming from a keyboard
+        // so checking 120 times per second is sufficient. But if
+        // the data comes from another processor, the port can
+        // theoretically receive as much as 11000 bytes/second
+        // (115200 baud). This delay can be removed and the
+        // Serial.Read() method can be used to retrieve
+        // multiple bytes from the receive buffer for each
+        // iteration.
+        time.Sleep(time.Millisecond * 8)
+    }
+}
+```
+
+You can flash this program to the microcontroller (in this example, a SAMD21 M0+
+clone that emulates an Arduino Zero), and fire up the monitor like this:
+
+```
+$ tinygo flash -target=arduino-zero
+$ tinygo monitor
+Connected to /dev/ttyACM0. Press Ctrl-C to exit.
+Reading from the serial port...
+abcdef^A^B^D^E^F^G^H^I^J^K^L^M^N^O^P^R^T^U^V^W^X^Y^^^[^]^_^?
+```
+
+Type a few characters in the `tinygo monitor`, for example "abcdef". You should
+see the characters echoed back by the microcontroller, as shown above. If you
+type a [nonprintable control
+characters](https://en.wikipedia.org/wiki/C0_and_C1_control_codes), these are
+echoed back as 2 characters: the caret character `^` and a letter representing
+the control character. For example, typing Control-P prints `^P`.
+
+Of the 32 possible control characters, some of them are intercepted by the
+`tinygo monitor` itself instead of being sent to the microcontroller:
+
+* Control-C: terminates the `tinygo monitor`
+* Control-Z: suspends the `tinygo monitor` and drops back into shell
+* Control-\\: terminates the `tinygo monitor` with a stack trace
+* Control-S: flow control, suspends output to the console
+* Control-Q: flow control, resumes output to the console
+* Control-@: thrown away by `tinygo monitor`
+
+## Alternative Serial Monitors
+
+There are many alternative serial monitor programs that can be used instead of
+`tinygo monitor`. The setup is slightly more complicated because you will need
+to supply the serial port and baud rate of the microcontroller as described in
+the [Serial Port on Host](#serial-port-on-host) and [Baud Rate](#baud-rate)
+subsections above.
+
+### Arduino IDE
+
+The [Arduino IDE](https://www.arduino.cc/en/software) contains its own serial
+monitor. You may choose to use that instead. You need to set the serial port
+(something like `/dev/ttyUSB0` on Linux, or `/dev/cu.usbserial-1420` on MacOS),
+and set the baud rate to 115200 (or 9600 on AVR processors).
+
+### pyserial
+
+The [pyserial](https://pyserial.readthedocs.io/en/latest/pyserial.html) is a
+Python library that comes with its own serial monitor. Setting up a python3
+environment is a complex topic that is beyond the scope of this document. But if
+you are able to install `python3` and `pip3`, you can install `pyserial` and use
+its built-in `miniterm` tool roughly like this:
+
+```
+$ python3 -m pip install --user pyserial
+$ python3 -m serial.tools.miniterm /dev/ttyUSB0 115200
+```
+
+Another useful feature of `pyserial` is the `list_ports` command:
+
+```
+$ python3 -m serial.tools.list_ports
+/dev/ttyACM0
+/dev/ttyS0
+/dev/ttyUSB0
+3 ports found
+```
+
+This is useful when you plug in a random microcontroller to the USB port, and
+you cannot remember which serial port it is mapped to.
+
+### picocom
+
+The [picocom](https://github.com/npat-efault/picocom) terminal emulator can be
+installed on both Linux and MacOS. If you are using an Ubuntu flavored Linux,
+the installation is something like:
+
+```
+$ sudo apt install picocom
+```
+
+On MacOS, most people use [Homebrew](https://brew.sh/), and it can be installed
+like this:
+
+```
+$ brew install picocom
+```
+
+It can be invoked like this:
+
+```
+$ picocom -b 115200 /dev/ttyACM0
+port is        : /dev/ttyACM0
+picocom v3.1
+[...]
+Type [C-a] [C-h] to see available commands
+Terminal ready
+```
diff --git a/content/faq/_index.md b/content/faq/_index.md
deleted file mode 100644
index 3691b667..00000000
--- a/content/faq/_index.md
+++ /dev/null
@@ -1,9 +0,0 @@
----
-title: "FAQ"
-chapter: true
-weight: 7
----
-
-# FAQ
-
-Here is where you can find the answers to the most frequently asked questions about TinyGo.
diff --git a/content/faq/what-about-esp8266-esp32.md b/content/faq/what-about-esp8266-esp32.md
deleted file mode 100644
index 91b54e89..00000000
--- a/content/faq/what-about-esp8266-esp32.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-title: "What about the ESP8266/ESP32?"
-weight: 5
----
-
-As of September 2020, we now have support for the ESP32 and ESP8266 in TinyGo!
-
-Please see https://tinygo.org/microcontrollers/esp32-mini32 and https://tinygo.org/microcontrollers/esp8266-nodemcu for more information.
diff --git a/content/getting-started/_index.md b/content/getting-started/_index.md
index c4294b1b..7a68c152 100644
--- a/content/getting-started/_index.md
+++ b/content/getting-started/_index.md
@@ -1,9 +1,17 @@
 ---
 title: "Getting Started"
-chapter: true
-weight: 1
----
+linkTitle: "Getting Started"
+type: "docs"
+weight: 5
+menu:
+  main:
+    weight: 5
 
-# Getting Started
+cascade:
+  github_repo: https://github.com/tinygo-org/tinygo-site
+  github_subdir: content/getting-started
+  path_base_for_github_subdir: content/getting-started
+  github_branch: dev
+---
 
-To use TinyGo, you must install it on your system. We have instructions for [Linux](linux), [macOS](macos), [Windows](windows), and [Docker](using-docker). You can also install TinyGo from source.
+New to TinyGo? This is the place to get started.
diff --git a/content/getting-started/install/_index.md b/content/getting-started/install/_index.md
new file mode 100644
index 00000000..28e5e0ca
--- /dev/null
+++ b/content/getting-started/install/_index.md
@@ -0,0 +1,12 @@
+---
+title: "Quick install guide"
+linkTitle: "Quick install"
+type: "docs"
+weight: 25
+description: >
+  Quick install guide
+---
+
+To install TinyGo, select the link for your operating system:
+
+You can use Docker if that's easier on your system or you would rather try TinyGo in a sandbox but note that it is not as convenient to use as installing TinyGo directly.
diff --git a/content/getting-started/install/linux.md b/content/getting-started/install/linux.md
new file mode 100644
index 00000000..7a35eca7
--- /dev/null
+++ b/content/getting-started/install/linux.md
@@ -0,0 +1,147 @@
+---
+title: "Linux"
+linkTitle: "Linux"
+type: "docs"
+weight: 35
+description: >
+  Linux install guide
+---
+
+This page has information on how to install and use TinyGo on Ubuntu, as well as other Linux distributions.
+
+If you want to use TinyGo to compile your own or sample code, you can install the release version directly on your machine by following the "Quick Install" instructions below.
+
+If you wish to build TinyGo from source, for example if you intend to contribute to the project, please take a look [here](../../../docs/guides/build).
+
+You can also install the development build of TinyGo if you want to test the latest version. For more information, please see [Development Builds](#development-builds).
+
+## Quick Install
+
+[Ubuntu/Debian](#ubuntu-debian)
+
+[Fedora Linux](#fedora-linux)
+
+[Arch Linux](#arch-linux)
+
+### Ubuntu/Debian
+
+You must have Go already installed on your machine in order to install TinyGo. We recommend Go v1.20 or above.
+
+If you are using Ubuntu or another Debian based Linux on an Intel processor, download the DEB file from Github and install it using the following commands:
+
+```shell
+wget https://github.com/tinygo-org/tinygo/releases/download/v0.39.0/tinygo_0.39.0_amd64.deb
+sudo dpkg -i tinygo_0.39.0_amd64.deb
+```
+
+If you are on a Raspberry Pi or other ARM-based Linux computer, you should use this command instead:
+
+```shell
+wget https://github.com/tinygo-org/tinygo/releases/download/v0.39.0/tinygo_0.39.0_armhf.deb
+sudo dpkg -i tinygo_0.39.0_armhf.deb
+```
+
+You will need to ensure that the path to the `tinygo` executable file is in your `PATH` variable.
+
+```shell
+export PATH=$PATH:/usr/local/bin
+```
+
+You can test that the installation is working properly by running this code which should display the version number:
+
+```shell
+$ tinygo version
+tinygo version 0.39.0 linux/amd64 (using go version go1.25.0 and LLVM version 19.1.2)
+```
+
+If you are on a 64 bit ARM OS, and running tinygo fails with "no such file or directory", you may need to install the 32 bit C++ runtime library, e.g.:
+
+```shell
+sudo apt install libstdc++6:armhf
+```
+
+If you are only interested in compiling TinyGo code for WebAssembly then you are now done with the installation.
+
+Otherwise, please continue with the installation of the additional requirements for your desired microcontroller.
+
+### Additional Requirements for Microcontrollers on Ubuntu/Debian
+
+Some boards require a special flashing tool for that particular chip, like `openocd` or `nrfjprog`. See the documentation page for your board as listed [here](../../../docs/reference/microcontrollers/) to see which flashing tool is required for your target board.
+
+If you are only interested in compiling TinyGo code for ARM microcontrollers then you are now done with the installation.
+
+#### AVR (e.g. Arduino Uno)
+
+To flash TinyGo programs for AVR based processors such as the original Arduino Uno you must install `avrdude`:
+
+```shell
+sudo apt-get install avrdude
+```
+
+This should allow you to flash TinyGo programs on an Arduino Uno or other supported AVR-based board.
+
+#### You are now done with the TinyGo "Quick Install" for Ubuntu/Debian
+
+### Fedora Linux
+
+There is an [Fedora 30 package](https://packages.fedoraproject.org/pkgs/tinygo/tinygo/) available for the latest TinyGo release. To install it:
+
+```shell
+sudo dnf install tinygo
+```
+
+If you are only interested in compiling TinyGo code for WebAssembly then you are now done with the installation.
+
+Otherwise, please continue with the installation of the additional requirements for your desired microcontroller
+
+### Additional Requirements for Microcontrollers on Fedora Linux
+
+There are some additional requirements to compile TinyGo programs that can run on microcontrollers.
+
+#### AVR (e.g. Arduino Uno)
+
+To compile and flash TinyGo programs for AVR based processors such as the original Arduino Uno you must install avrdude:
+
+```shell
+sudo dnf install avrdude
+```
+
+This should allow you to flash TinyGo programs on an Arduino or other supported AVR-based board.
+
+#### You are now done with the TinyGo "Quick Install" for Fedora Linux
+
+### Arch Linux
+
+There is an [Arch package](https://archlinux.org/packages/extra/x86_64/tinygo/) available for the latest TinyGo release.
+
+If you are only interested in compiling TinyGo code for WebAssembly then you are now done with the installation.
+
+Otherwise, please continue with the installation of the additional requirements for your desired microcontroller
+
+### Additional Requirements for Microcontrollers on Arch Linux
+
+There are some additional requirements to compile TinyGo programs that can run on microcontrollers.
+
+#### AVR (e.g. Arduino Uno)
+
+To compile and flash TinyGo programs for AVR based processors such as the original Arduino Uno you must install avrdude:
+
+[avrdude package](https://archlinux.org/packages/extra/x86_64/avrdude/)
+
+This should allow you to flash TinyGo programs on an Arduino or other supported AVR-based board.
+
+#### You are now done with the TinyGo "Quick Install" for Arch Linux
+
+### Development Builds
+
+You can download the latest builds from the TinyGo `dev` branch where active development takes place.
+
+To obtain the binary, first go to the list of recent actions for the Linux build:
+
+https://github.com/tinygo-org/tinygo/actions/workflows/linux.yml?query=branch%3Adev
+
+Click on the link for the build you want to download. The most recent one is located at the top.
+
+Scroll down on that page to the "Artifacts" and click to download the file for your desired architecture, for example "linux-amd64-double-zipped".
+
+As you might suspect from the name, the file is a compressed zip file that contains the zip file with the actual TinyGo build. Extract that to your desired location, and run it to try the latest features and fixes.
diff --git a/content/getting-started/install/macos.md b/content/getting-started/install/macos.md
new file mode 100644
index 00000000..52e64fee
--- /dev/null
+++ b/content/getting-started/install/macos.md
@@ -0,0 +1,96 @@
+---
+title: "macOS"
+linkTitle: "macOS"
+type: "docs"
+weight: 45
+description: >
+  macOS install guide
+---
+
+This page has information on how to install and use TinyGo on macOS. If you wish to build TinyGo from source, for example if you intend to contribute to the project, please take a look [here](../../../docs/guides/build).
+
+You must have Go v1.20+ already installed on your machine in order to install TinyGo.
+
+You can use Homebrew to install TinyGo using the following commands:
+
+```shell
+brew tap tinygo-org/tools
+brew install tinygo
+```
+
+### Alternative installation
+
+#### Mac M1/M2
+
+Download [this](https://github.com/tinygo-org/tinygo/releases/download/v0.39.0/tinygo0.39.0.darwin-arm64.tar.gz) file. Then, run the following commands:
+
+```shell
+tar xvzf tinygo0.39.0.darwin-arm64.tar.gz
+export PATH=<extract location>/tinygo/bin:$PATH
+```
+
+You can test that the installation is working properly by running this code which should display the version number:
+
+```shell
+$ tinygo version
+tinygo version 0.39.0 darwin/arm64 (using go version go1.25.0 and LLVM version 19.1.2)
+```
+
+If you are only interested in compiling TinyGo code for WebAssembly then you are done with the installation.
+
+Otherwise, please continue with the installation of the additional requirements for your desired microcontroller.
+
+#### Mac Intel
+
+Download [this](https://github.com/tinygo-org/tinygo/releases/download/v0.39.0/tinygo0.39.0.darwin-amd64.tar.gz) file. Then, run the following commands:
+
+```shell
+tar xvzf tinygo0.39.0.darwin-amd64.tar.gz
+export PATH=<extract location>/tinygo/bin:$PATH
+```
+
+You can test that the installation is working properly by running this code which should display the version number:
+
+```shell
+$ tinygo version
+tinygo version 0.39.0 darwin/amd64 (using go version go1.25.0 and LLVM version 19.1.2)
+```
+
+If you are only interested in compiling TinyGo code for WebAssembly then you are done with the installation.
+
+Otherwise, please continue with the installation of the additional requirements for your desired microcontroller.
+
+### Additional Requirements for Microcontrollers
+
+If you are only interested in compiling TinyGo code for ARM microcontrollers then you are now done with the installation.
+
+Some boards require a special flashing tool for that particular chip, like `openocd` or `nrfjprog`. See the documentation page for your board as listed [here](../../../docs/reference/microcontrollers/) to see which flashing tool is required for your target board.
+
+The boards with USB Mass Storage Device flashing method, like Raspberry Pi Pico (RP2040), reboot and detach "unsafely" during flashing procedure.  
+This behaviour upsets OS and it shows a modal notification one shall unmount USB drive properly first.  
+To suppress this notification, run the following command and restarting your Mac after that.  
+```
+sudo defaults write /Library/Preferences/SystemConfiguration/com.apple.DiskArbitration.diskarbitrationd.plist DADisableEjectNotification -bool YES && sudo pkill diskarbitrationd
+```
+
+#### AVR (e.g. Arduino Uno)
+
+To flash TinyGo programs for AVR based processors such as the original Arduino Uno you must install `avrdude`:
+
+```shell
+brew install avrdude
+```
+
+### Development Builds
+
+You can download the latest builds from the TinyGo `dev` branch where active development takes place.
+
+To obtain the binary, first go to the list of recent actions for the macOS build:
+
+https://github.com/tinygo-org/tinygo/actions/workflows/build-macos.yml?query=branch%3Adev
+
+Click on the link for the build you want to download. The most recent one is located at the top.
+
+Scroll down on that page to the "Artifacts" and click to download the file named "release-double-zipped".
+
+As you might suspect from the name, the file is a compressed zip file that contains the zip file with the actual TinyGo build. Extract that to your desired location, and run it to try the latest features and fixes.
diff --git a/content/getting-started/using-docker.md b/content/getting-started/install/using-docker.md
similarity index 72%
rename from content/getting-started/using-docker.md
rename to content/getting-started/install/using-docker.md
index ca8fcfae..b83d46d4 100644
--- a/content/getting-started/using-docker.md
+++ b/content/getting-started/install/using-docker.md
@@ -1,13 +1,15 @@
 ---
 title: "Docker"
-weight: 4
+linkTitle: "Docker"
+type: "docs"
+weight: 55
 ---
 
 You can use our Docker image to be able to run the TinyGo compiler on your computer without having to install all the dependencies. Read on to learn how.
 
 ## Installing
 
-    docker pull tinygo/tinygo:0.16.0
+    docker pull tinygo/tinygo:0.39.0
 
 ## Using
 
@@ -16,24 +18,24 @@ For your own code, you will probably want to use absolute paths.
 
 A docker container exists for easy access to the TinyGo CLI. For example, to compile `wasm.wasm` for the WebAssembly export example:
 
-    docker run --rm -v $(pwd):/src tinygo/tinygo:0.16.0 tinygo build -o wasm.wasm -target=wasm examples/wasm/export
+    docker run --rm -v $(pwd):/src tinygo/tinygo:0.39.0 tinygo build -o wasm.wasm -target=wasm examples/wasm/export
 
-See the [WebAssembly page](../../webassembly) for more information on executing the compiled
+See the [WebAssembly page](../../../docs/guides/webassembly) for more information on executing the compiled
 WebAssembly.
 
 To compile `blinky1.hex` targeting an ARM microcontroller, such as the PCA10040:
 
-    docker run --rm -v $(pwd):/src tinygo/tinygo:0.16.0 tinygo build -o /src/blinky1.hex -size=short -target=pca10040 examples/blinky1
+    docker run --rm -v $(pwd):/src tinygo/tinygo:0.39.0 tinygo build -o /src/blinky1.hex -size=short -target=pca10040 examples/blinky1
 
 To compile `blinky1.hex` targeting an AVR microcontroller such as the Arduino:
 
-    docker run --rm -v $(pwd):/src tinygo/tinygo:0.16.0 tinygo build -o /src/blinky1.hex -size=short -target=arduino examples/blinky1
+    docker run --rm -v $(pwd):/src tinygo/tinygo:0.39.0 tinygo build -o /src/blinky1.hex -size=short -target=arduino examples/blinky1
 
 For projects that have remote dependencies outside of the standard library and
 go code within your own project, you will need to map your entire `$GOPATH`
 into the docker image for those dependencies to be found:
 
-    docker run -v $GOPATH:/go -e "GOPATH=/go" tinygo/tinygo:0.16.0 tinygo build -o /go/src/github.com/myuser/myrepo/wasm.wasm -target wasm --no-debug /go/src/github.com/myuser/myrepo/wasm-main.go
+    docker run -v $GOPATH:/go -e "GOPATH=/go" tinygo/tinygo:0.39.0 tinygo build -o /go/src/github.com/myuser/myrepo/wasm.wasm -target wasm --no-debug /go/src/github.com/myuser/myrepo/wasm-main.go
 
 **note: At this time, tinygo does not resolve dependencies from the /vendor/ folder within your project.**
 
@@ -43,3 +45,9 @@ So your workflow could be:
 
 - Compile TinyGo code using the Docker container into a HEX file.
 - Flash the HEX file from your host environment to the target microcontroller.
+
+### Development Builds
+
+You can also use the Docker image with the latest builds from the TinyGo `dev` branch where active development takes place:
+
+    docker pull tinygo/tinygo-dev:latest
diff --git a/content/getting-started/install/windows.md b/content/getting-started/install/windows.md
new file mode 100644
index 00000000..d4cb4f2c
--- /dev/null
+++ b/content/getting-started/install/windows.md
@@ -0,0 +1,179 @@
+---
+title: "Windows"
+linkTitle: "Windows"
+type: "docs"
+weight: 65
+description: >
+  Windows install guide
+---
+
+This page has information on how to install and use TinyGo on Windows 10. If you wish to build TinyGo from source, for example if you intend to contribute to the project, please take a look [here](../../../docs/guides/build).
+
+TinyGo requires Go v1.20+ to be already installed on your machine.
+
+### Quick Install via Scoop
+
+You can use [Scoop](https://scoop.sh/) to install TinyGo and dependencies.
+
+If you haven't installed Go already, you can do so with the following command:
+
+```shell
+> scoop install go
+```
+
+Followed by TinyGo itself:
+
+```shell
+> scoop install tinygo
+```
+
+Your `$PATH` environment variable will be updated via the scoop package. By default a shim is created in `~/scoop/shims/tinygo`.
+
+You can test that the installation was successful by running the `version` command which should display the version number:
+
+```shell
+> tinygo version
+tinygo version 0.39.0 windows/amd64 (using go version go1.25.0 and LLVM version 19.1.2)
+```
+
+Upgrading to the latest TinyGo version can be done via scoop with:
+
+```shell
+> scoop update tinygo
+```
+
+#### WebAssembly/WASI
+
+If you want to compile programs on Windows that will target WebAssembly or WASI, you need to install the `binaryen` tool via Scoop:
+
+```shell
+> scoop install binaryen
+```
+
+Upgrading to the latest versions can be as easy as:
+
+```shell
+> scoop update binaryen
+```
+
+#### AVR (e.g. Arduino Uno)
+
+If you want to flash programs on older Arduino boards such as the Arduino Uno, you need to install the `avrdude` tool via Scoop:
+
+```shell
+> scoop install avrdude
+```
+
+Upgrading to the latest versions can be as easy as:
+
+```shell
+> scoop update avrdude
+```
+
+
+### Manual Install
+
+- You MUST use Go 1.20.x+ with the Windows 10 native install of TinyGo.
+
+    - If you have not installed it yet, you can get it from https://golang.org/dl/
+
+    - Choose the download link for Microsoft Windows, Windows 7 or later, Intel 64-bit processor.
+
+- Download the TinyGo binary for Windows file from https://github.com/tinygo-org/tinygo/releases/download/v0.39.0/tinygo0.39.0.windows-amd64.zip
+
+- Decompress the file like this:
+
+    - First double click on the downloaded ZIP file to open it.
+
+    - Now drag the "tinygo" folder in the ZIP file window onto your "C:" drive.
+
+    - When the folder is finished extracting, you can close the ZIP file window.
+
+- You will need to add `C:\tinygo\bin` to your PATH.
+
+    ```shell
+    > set PATH=%PATH%;"C:\tinygo\bin";
+    ```
+
+- The above is fine for testing, but to change your PATH in a way that survives reboots, you'll need to use a different method, e.g.
+
+    - Click the Start button or press the Windows key.
+    - In the search bar, type env.
+    - From the search results, choose the option that says "Edit the system environment variables." This will open the System Properties window.
+    - In the System Properties window, navigate to the "Advanced" tab and then click the "Environment Variables..." button. This will open the Environment Variables window.
+    - Select PATH in User Variables and click edit, then add C:\tinygo\bin to the list.
+    - Click "OK" on all open dialog boxes to save them
+    - Reboot
+
+- Now you should be able to run the TinyGo command:
+
+    ```
+    > tinygo version
+    tinygo version 0.39.0 windows/amd64 (using go version go1.25.0 and LLVM version 19.1.2)
+    ```
+
+### Flashing boards
+
+#### Adafruit Circuit Playground Express
+
+Many boards from Adafruit, such as the Circuit Playground Express, use the `UF2` format. This binary format does not require installing any additional flashing tools.
+
+- Plug in the Circuit Playground Express board to the USB port.
+
+- Double tap the "RESET" button.
+
+- Once the Circuit Playground Express board appears as a flash drive, run the following command:
+
+    ```shell
+    tinygo flash -target circuitplay-express examples/blinky1
+    ```
+
+The board should restart and begin running your program.
+
+#### Arduino Nano33 IoT
+
+- You must install the "BOSSA" flashing utility first. You can download it from https://github.com/shumatech/BOSSA/releases/download/1.9.1/bossa-x64-1.9.1.msi
+
+- During the installation, make sure that you choose to put it into `c:\Program Files`. The default in the installer will not work correct, you must choose `c:\Program Files`.
+
+- After the installation, you must add BOSSA to your PATH:
+
+    ```shell
+    set PATH=%PATH%;"c:\Program Files\BOSSA";
+    ```
+
+- Test that you have installed "BOSSA" correctly by running this command:
+
+    ```shell
+    bossac --help
+    ```
+
+Now you can flash your Arduino Nano33 board like this:
+
+- Plug in the Arduino Nano33 IoT board to the USB port.
+
+- Double tap the "RESET" button.
+
+- Windows 10 should display a notification with the name of the COM port that the board has been assigned to. For example `COM4`.
+
+- Run the following command:
+
+    ```shell
+    tinygo flash -target arduino-nano33 path\to\code
+    ```
+
+The board should restart and begin running your program.
+
+### Development Builds
+
+You can download the latest builds from the TinyGo `dev` branch where active development takes place.
+
+To obtain the binary, first go to the list of recent actions for the Windows build:
+
+https://github.com/tinygo-org/tinygo/actions/workflows/windows.yml?query=branch%3Adev
+
+Click on the link for the build you want to download. The most recent one is located at the top.
+
+Scroll down on that page to the "Artifacts" and click to download the file named "release-double-zipped".
+
+As you might suspect from the name, the file is a compressed zip file that contains the zip file with the actual TinyGo build. Extract that to your desired location, and run it to try the latest features and fixes.
diff --git a/content/getting-started/linux.md b/content/getting-started/linux.md
deleted file mode 100644
index 4e18698c..00000000
--- a/content/getting-started/linux.md
+++ /dev/null
@@ -1,237 +0,0 @@
----
-title: "Linux"
-date: 2019-04-15T11:41:45+02:00
-draft: false
-weight: 1
----
-
-This page has information on how to install and use TinyGo on Ubuntu, as well as other Linux distributions.
-
-If you want to use TinyGo to compile your own or sample code, you can install the release version directly on your machine by following the "Quick Install" instructions below.
-
-You can instead install the full source code to the TinyGo compiler itself, generally for people who wish to contribute to the project or want to build the compiler from sources.
-
-The third option is to use the Docker image. This has the benefit of making no changes to your system, however the image has a large download and installation size. For instructions on using the Docker image, please see the page [here](../using-docker).
-
-## Quick Install
-
-[Ubuntu/Debian](#ubuntu-debian)
-
-[Fedora Linux](#fedora-linux)
-
-[Arch Linux](#arch-linux)
-
-### Ubuntu/Debian
-
-You must have Go already installed on your machine in order to install TinyGo. We recommend Go v1.14 or above.
-
-If you are using Ubuntu or another Debian based Linux on an Intel processor, download the DEB file from Github and install it using the following commands:
-
-```shell
-wget https://github.com/tinygo-org/tinygo/releases/download/v0.16.0/tinygo_0.16.0_amd64.deb
-sudo dpkg -i tinygo_0.16.0_amd64.deb
-```
-
-If you are on a Raspberry Pi or other ARM-based Linux computer, you should use this command instead:
-
-```shell
-wget https://github.com/tinygo-org/tinygo/releases/download/v0.16.0/tinygo_0.16.0_arm.deb
-sudo dpkg -i tinygo_0.16.0_arm.deb
-```
-
-You will need to ensure that the path to the `tinygo` executable file is in your `PATH` variable.
-
-```shell
-export PATH=$PATH:/usr/local/tinygo/bin
-```
-
-You can test that the installation is working properly by running this code which should display the version number:
-
-```shell
-$ tinygo version
-tinygo version 0.16.0 linux/amd64 (using go version go1.15 and LLVM version 10.0.1)
-```
-
-If you are only interested in compiling TinyGo code for WebAssembly then you are now done with the installation.
-
-Otherwise, please continue with the installation of the additional requirements for your desired microcontroller.
-
-### Additional Requirements for Microcontrollers on Ubuntu/Debian
-
-Some boards require a special flashing tool for that particular chip, like `openocd` or `nrfjprog`. See the documentation page for your board as listed [here](../../microcontrollers/) to see which flashing tool is required for your target board.
-
-If you are only interested in compiling TinyGo code for ARM microcontrollers then you are now done with the installation.
-
-#### AVR (e.g. Arduino Uno)
-
-To compile and flash TinyGo programs for AVR based processors such as the original Arduino Uno you must install some extra tools:
-
-```shell
-sudo apt-get install gcc-avr
-sudo apt-get install avr-libc
-sudo apt-get install avrdude
-```
-
-This should allow you to compile and flash TinyGo programs on an Arduino or other supported AVR-based board.
-
-#### You are now done with the TinyGo "Quick Install" for Ubuntu/Debian
-
-### Fedora Linux
-
-There is an [Fedora 30 package](https://apps.fedoraproject.org/packages/tinygo) available for the latest TinyGo release. To install it:
-
-```shell
-sudo dnf install tinygo
-```
-
-If you are only interested in compiling TinyGo code for WebAssembly then you are now done with the installation.
-
-Otherwise, please continue with the installation of the additional requirements for your desired microcontroller
-
-### Additional Requirements for Microcontrollers on Fedora Linux
-
-There are some additional requirements to compile TinyGo programs that can run on microcontrollers.
-
-#### AVR (e.g. Arduino Uno)
-
-To compile and flash TinyGo programs for AVR based processors such as the original Arduino Uno you must install some extra tools:
-
-```shell
-sudo dnf install avr-gcc
-sudo dnf install avr-libc
-sudo dnf install avrdude
-```
-
-This should allow you to compile and flash TinyGo programs on an Arduino or other supported AVR-based board.
-
-#### You are now done with the TinyGo "Quick Install" for Fedora Linux
-
-### Arch Linux
-
-There is an [AUR package](https://aur.archlinux.org/packages/tinygo-bin/) available for the latest TinyGo release.
-
-If you are only interested in compiling TinyGo code for WebAssembly then you are now done with the installation.
-
-Otherwise, please continue with the installation of the additional requirements for your desired microcontroller
-
-### Additional Requirements for Microcontrollers on Arch Linux
-
-There are some additional requirements to compile TinyGo programs that can run on microcontrollers.
-
-#### AVR (e.g. Arduino Uno)
-
-To compile and flash TinyGo programs for AVR based processors such as the original Arduino Uno you must install some extra tools:
-
-[avr-gcc package](https://www.archlinux.org/packages/community/x86_64/avr-gcc/)
-
-[avr-libc package](https://www.archlinux.org/packages/community/any/avr-libc/)
-
-[avrdude package](https://www.archlinux.org/packages/community/x86_64/avrdude/)
-
-This should allow you to compile and flash TinyGo programs on an Arduino or other supported AVR-based board.
-
-#### You are now done with the TinyGo "Quick Install" for Arch Linux
-
-## Source Install
-
-***If you have already followed the "Quick Install" instructions above for your distro, you do not need to perform a source install. You are now done with the needed installation. The "Source Install" is for when you want to contribute to TinyGo.***
-
-Start with getting the source code:
-
-```shell
-git clone --recursive https://github.com/tinygo-org/tinygo.git
-cd tinygo
-```
-
-You now have two options: build LLVM manually or use a LLVM distributed with
-your package manager. The advantage of a manual build is that it includes all
-supported targets (including AVR), which not all prebuilt LLVM packages provide.
-
-### With system-installed LLVM
-
-You can use LLVM included with the package manager of your distribution. How
-this is done depends on your system. If you have gotten it to work on a
-different distribution, please let us know how so we can add it here.
-
-For Debian and Ubuntu, you can install the binaries provided by LLVM on
-[apt.llvm.org](http://apt.llvm.org/). For example, the following commands can be
-used to install LLVM 10 on Debian Buster:
-
-```shell
-echo 'deb http://apt.llvm.org/buster/ llvm-toolchain-buster-10 main' | sudo tee /etc/apt/sources.list.d/llvm.list
-wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
-sudo apt-get update
-sudo apt-get install clang-10 llvm-10-dev lld-10 libclang-10-dev
-```
-
-Installing TinyGo should now be as easy as:
-
-```shell
-go install
-```
-
-Note that you should not use `make` when you want to build using a
-system-installed LLVM, just use the Go toolchain. `make` is used when you want
-to use a self-built LLVM.
-
-### With a self-built LLVM
-
-You can also manually build LLVM. This is a long process which takes at least
-one hour on most machines. In most cases you can build TinyGo using a
-system-installed LLVM. However, some builds do not support the experimental AVR
-target so you'll have to build from source if you want to use TinyGo for the
-Arduino Uno. The binaries from apt.llvm.org do provide the AVR target, however.
-
-You will need a few extra tools that are required during the build of LLVM,
-depending on your distribution. Debian and Ubuntu users can install all required
-tools this way:
-
-```shell
-sudo apt-get install build-essential git cmake ninja
-```
-
-On Debian use `ninja-build` package instead of `ninja`.
-
-The following command takes care of downloading and building LLVM. It places the
-source code in `llvm-project/` and the build output in `llvm-build/`. It only
-needs to be done once until the next LLVM release. Note that the `export` lines
-are optional, but using Clang during the build speeds up the build
-significantly.
-
-```shell
-export CC=clang
-export CXX=clang++
-make llvm-build
-```
-
-Once this is finished, you can build TinyGo against this manually built LLVM:
-
-```shell
-make
-```
-
-This results in a `tinygo` binary in the `build` directory:
-
-```shell
-$ ./build/tinygo version
-tinygo version 0.16.0 linux/amd64 (using go version go1.15 and LLVM version 10.0.1)
-```
-
-### Additional Requirements for Microcontrollers
-
-Before anything can be built for a bare-metal target, you need to generate some
-files first:
-
-```shell
-make gen-device
-```
-
-This will generate register descriptions, interrupt vectors, and linker scripts
-for various devices. Also, you may need to re-run this command after updates,
-as some updates cause changes to the generated files.
-
-The same additional requirements to compile TinyGo programs that can run on microcontrollers must be fulfilled when installing TinyGo from source. Please follow [these instructions](#additional-requirements-for-microcontrollers) above.
-
-## Docker Install
-
-The TinyGo Docker image contains a complete development environment for both WASM and microcontroller development already setup. For instructions on using the Docker image, please see the page [here](../using-docker).
diff --git a/content/getting-started/macos.md b/content/getting-started/macos.md
deleted file mode 100644
index 6ec65d64..00000000
--- a/content/getting-started/macos.md
+++ /dev/null
@@ -1,143 +0,0 @@
----
-title: "macOS"
-date: 2019-04-15T11:41:45+02:00
-draft: false
-weight: 1
----
-
-This page has information on how to install and use TinyGo on macOS.
-
-If you want to use TinyGo to compile your own or sample code, you can install the release version directly on your machine by following the "Quick Install" instructions below.
-
-You can also install the full source code to the TinyGo compiler itself, generally for people who wish to contribute to the project or want to build the compiler from sources directly.
-
-The third option is to use the Docker image. This has the benefit of making no changes to your system but has a large download and installation size. For instructions on using the Docker image, please see the page [here](../using-docker).
-
-## Quick Install
-
-You must have Go v1.12+ already installed on your machine in order to install TinyGo. We recommend Go v1.14+.
-
-You can use Homebrew to install TinyGo using the following commands:
-
-```shell
-brew tap tinygo-org/tools
-brew install tinygo
-```
-
-You can test that the installation is working properly by running this code which should display the version number:
-
-```shell
-$ tinygo version
-tinygo version 0.16.0 darwin/amd64 (using go version go1.15 and LLVM version 10.0.1)
-```
-
-If you are only interested in compiling TinyGo code for WebAssembly then you are done with the installation.
-
-Otherwise, please continue with the installation of the additional requirements for your desired microcontroller.
-
-### Additional Requirements for Microcontrollers
-
-Some boards require a special flashing tool for that particular chip, like `openocd` or `nrfjprog`. See the documentation page for your board as listed [here](../../microcontrollers/) to see which flashing tool is required for your target board.
-
-If you are only interested in compiling TinyGo code for ARM microcontrollers then you are now done with the installation.
-
-#### AVR (e.g. Arduino Uno)
-
-To compile and flash TinyGo programs for AVR based processors such as the original Arduino Uno you must install some extra tools:
-
-```shell
-brew tap osx-cross/avr
-brew install avr-gcc
-brew install avrdude
-```
-
-### You are now done with the TinyGo "Quick Install" for macOS
-
-## Source Install
-
-***If you have already followed the "Quick Install" instructions above, you do not need to perform a source install. You are now done with the needed installation. The "Source Install" is for when you want to contribute to TinyGo.***
-
-Start with getting the source code:
-
-```shell
-git clone --recursive https://github.com/tinygo-org/tinygo.git
-cd tinygo
-```
-
-You now have two options: build LLVM manually or use LLVM from Homebrew. The
-advantage of a manual build is that it includes all supported targets (including
-AVR) while Homebrew includes only stable targets. Unless you want to compile for
-AVR-based boards, you can use Homebrew.
-
-### With LLVM from Homebrew
-
-The easiest way to install LLVM on macOS is through
-[Homebrew](https://formulae.brew.sh/formula/llvm). Make sure you install LLVM 10:
-
-```shell
-brew install llvm
-```
-
-Installing TinyGo should now be as easy as:
-
-```shell
-go install
-```
-
-Note that you should not use `make` when you want to build using a
-system-installed LLVM, just use the Go toolchain. `make` is used when you want
-to use a self-built LLVM.
-
-### With a self-built LLVM
-
-You can also manually build LLVM. This is a long process which takes at least
-one hour on most machines. In most cases you can build TinyGo using LLVM from
-Homebrew. However, the Homebrew build does not support the experimental AVR
-target so you'll have to build from source if you want to use TinyGo for the
-Arduino Uno.
-
-You will need a few extra tools that are required during the build of LLVM:
-
-```shell
-brew install cmake ninja
-```
-
-The following command takes care of downloading and building LLVM. It places the
-source code in `llvm-project/` and the build output in `llvm-build/`. It only
-needs to be done once until the next LLVM release.
-
-```shell
-make llvm-build
-```
-
-Once this is finished, you can build TinyGo against this manually built LLVM:
-
-```shell
-make
-```
-
-This results in a `tinygo` binary in the `build` directory:
-
-```shell
-$ ./build/tinygo version
-tinygo version 0.16.0 darwin/amd64 (using go version go1.15 and LLVM version 10.0.1)
-```
-
-### Additional Requirements for Microcontrollers
-
-Before anything can be built for a bare-metal target, you need to generate some
-files first:
-
-```shell
-make gen-device
-```
-
-This will generate register descriptions, interrupt vectors, and linker scripts
-for various devices. Also, you may need to re-run this command after updates,
-as some updates cause changes to the generated files.
-
-The same additional requirements to compile TinyGo programs that can run on microcontrollers must be fulfilled when installing TinyGo from source. Please follow [these instructions](#additional-requirements-for-microcontrollers) above.
-
-## Docker Install
-
-For instructions on using the Docker image, please see the page [here](../using-docker).
diff --git a/content/getting-started/overview/_index.md b/content/getting-started/overview/_index.md
new file mode 100644
index 00000000..4dbed19a
--- /dev/null
+++ b/content/getting-started/overview/_index.md
@@ -0,0 +1,63 @@
+---
+title: "Overview"
+linkTitle: "Overview"
+type: "docs"
+weight: 20
+description: >
+  Short introduction to TinyGo
+---
+
+TinyGo is a new compiler for an existing programming language, the [Go programming language](https://golang.org/). TinyGo focuses on compiling code written in Go, but for smaller kinds of systems:
+
+  - The Go compiler and tools (from [golang.org](https://golang.org/)) are the reference implementation of the Go programming language. They are primarily intended for server side programming but also used for command line tools and other purposes.
+  - The TinyGo project implements the [exact same programming language](https://golang.org/ref/spec). However, TinyGo uses a different compiler and tools to make it suited for embedded systems and WebAssembly. It does this primarily by creating much smaller binaries and targeting a much wider variety of systems.
+
+For example, the following piece of code does exactly the same thing in both compilers:
+
+```go
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("Hello world!")
+}
+```
+
+You can compile it with similar commands:
+
+```shell
+go build -o hello ./hello.go
+```
+
+```shell
+tinygo build -o hello ./hello.go
+```
+
+The programming language is the same. The standard library (including the fmt package) is the same. The only difference here, is which compiler is used, and the associated runtime.
+
+What is significantly different is the output binary size. Here are the executables produced by each compiler:
+
+```shell
+1937340 may 12 12:42 helloworld-with-fmt.go1.16.3
+ 251376 may 12 12:42 helloworld-with-fmt.tinygo0.18
+```
+
+And then again after having the `strip` command run on each to remove all symbols and debugging info:
+
+```shell
+ 837624 may 12 20:03 helloworld-with-fmt.go1.16.3-stripped
+  10392 may 12 20:05 helloworld-with-fmt.tinygo0.18-stripped
+```
+
+In this case the Go compiled binary is 837k in size (or 1.9MB before stripping) while TinyGo produces a binary of only 10k in size (251k before stripping)!
+
+This is 1% of the size of the original binary, which allows such binaries to be used on much smaller systems that were previously unsupported, simply because of the binary size.
+
+By using TinyGo you can actually compile and run a binary on a variety of bare metal hardware platforms. For example, you can run this program directly on a [BBC micro:bit](https://microbit.org/):
+
+    tinygo flash -target=microbit ./hello.go
+
+Many different boards from vendors such as [Adafruit](https://www.adafruit.com/) and [Arduino](https://www.arduino.cc/) and many other companies are supported. For a complete list, see [this list](../../../docs/reference/microcontrollers).
+
+Interested? Play around a bit with it on our [playground](https://play.tinygo.org/) or continue with [installing TinyGo](../install).
diff --git a/content/getting-started/tour.md b/content/getting-started/tour.md
new file mode 100644
index 00000000..dad28aee
--- /dev/null
+++ b/content/getting-started/tour.md
@@ -0,0 +1,8 @@
+---
+title: "Tour"
+type: "docs"
+---
+
+We have a Tour of TinyGo, where you'll learn how to use TinyGo even if you aren't very familiar with programming hardware. You can find it [here]({{< ref "tour/blink/onboard.md" >}}).
+
+The tour assumes you are already familiar with Go. If not, you can follow the [Tour of Go](https://go.dev/tour/) to get started.
diff --git a/content/getting-started/windows.md b/content/getting-started/windows.md
deleted file mode 100644
index 966efd48..00000000
--- a/content/getting-started/windows.md
+++ /dev/null
@@ -1,208 +0,0 @@
----
-title: "Windows"
-date: 2019-04-15T11:41:45+02:00
-draft: false
-weight: 3
----
-
-This page has information on how to install and use TinyGo on Windows 10.
-
-## Windows Native Install
-
-We now have a native install for Windows 10.
-
-> **VERY IMPORTANT NOTE:** 
-> You cannot yet create Windows binary programs using TinyGo, only MCU and WASM targets.
-
-TinyGo requires Go v1.14+ to be already installed on your machine.
-
-### Quick Install via Scoop
-
-You can use [Scoop](https://scoop.sh/) to install TinyGo and dependencies.
-
-If you haven't installed Go already, you can do so with the following command:
-
-```shell
-> scoop install go
-```
-
-Followed by TinyGo itself:
-
-```shell
-> scoop install tinygo
-```
-
-Your `$PATH` environment variable will be updated via the scoop package. By default a shim is created in `~/scoop/shims/tinygo`.
-
-You can test that the installation was successful by running the `version` command which should display the version number:
-
-```shell
-> tinygo version
-tinygo version 0.16.0 windows/amd64 (using go version go1.15 and LLVM version 10.0.1)
-```
-
-Upgrading to the latest TinyGo version can be done via scoop with:
-
-```shell
-> scoop update tinygo
-```
-
-### Manual Install
-
-- You MUST use Go 1.14.x+ with the Windows 10 native install of TinyGo.
-
-    - If you have not installed it yet, you can get it from https://golang.org/dl/
-
-    - Choose the download link for Microsoft Windows, Windows 7 or later, Intel 64-bit processor.
-
-- Download the TinyGo binary for Windows file from https://github.com/tinygo-org/tinygo/releases/download/v0.16.0/tinygo0.16.0.windows-amd64.zip
-
-- Decompress the file like this:
-
-    - First double click on the downloaded ZIP file to open it.
-
-    - Now drag the "tinygo" folder in the ZIP file window onto your "C:" drive.
-
-    - When the folder is finished extracting, you can close the ZIP file window.
-
-- You will need to add `C:\tinygo\bin` to your PATH.
-
-    ```shell
-    > set PATH=%PATH%;"C:\tinygo\bin";
-    ```
-
-- Now you should be able to run the TinyGo command:
-
-    ```
-    > tinygo version
-    tinygo version 0.16.0 windows/amd64 (using go version go1.15 and LLVM version 10.0.1)
-    ```
-
-### Flashing boards
-
-#### Adafruit Circuit Playground Express
-
-Many boards from Adafruit, such as the Circuit Playground Express, use the `UF2` format. This binary format does not require installing any additional flashing tools.
-
-- Plug in the Circuit Playground Express board to the USB port.
-
-- Double tap the "RESET" button.
-
-- Once the Circuit Playground Express board appears as a flash drive, run the following command:
-
-    ```shell
-    tinygo flash -target circuitplay-express examples/blinky1
-    ```
-
-The board should restart and begin running your program.
-
-#### Arduino Nano33 IoT
-
-- You must install the "BOSSA" flashing utility first. You can download it from https://github.com/shumatech/BOSSA/releases/download/1.9.1/bossa-x64-1.9.1.msi
-
-- During the installation, make sure that you choose to put it into `c:\Program Files`. The default in the installer will not work correct, you must choose `c:\Program Files`.
-
-- After the installation, you must add BOSSA to your PATH:
-
-    ```shell
-    set PATH=%PATH%;"c:\Program Files\BOSSA";
-    ```
-
-- Test that you have installed "BOSSA" correctly by running this command:
-
-    ```shell
-    bossac --help
-    ```
-
-Now you can flash your Arduino Nano33 board like this:
-
-- Plug in the Arduino Nano33 IoT board to the USB port.
-
-- Double tap the "RESET" button.
-
-- Windows 10 should display a notification with the name of the COM port that the board has been assigned to. For example `COM4`.
-
-- Run the following command:
-
-    ```shell
-    tinygo flash -target arduino-nano33 path\to\code
-    ```
-
-The board should restart and begin running your program.
-
-## WSL Install
-
-If you want to use TinyGo to compile your own or sample code, you should be able to install the release version directly on your machine using Windows Subsystem for Linux (WSL) by following the "Quick Install" instructions on the Linux page located [here](../linux).
-
-## Docker Install
-
-Another option is to use the Docker image. This has the benefit of making no changes to your system but has a large download and installation size. For instructions on using the Docker image, please see the page [here](../using-docker).
-
-## Source Install
-
-***If you have already followed the "Windows Native Install" instructions above, you do not need to perform a source install. You are now done with the needed installation. The "Source Install" is for when you want to contribute to TinyGo.***
-
-Be warned that building TinyGo on Windows is not tested as well as building TinyGo on other operating systems (such as Linux). If you want to contribute to TinyGo but don't need to run natively on Windows, it may be easier and faster to do development within [WSL](https://docs.microsoft.com/en-us/windows/wsl/install-win10). See the [Linux page](../linux) for how to build TinyGo on Linux.
-
-### Dependencies
-
-You will need to have the following programs installed on your Windows system and configured to be accessible in your PATH variable:
-
-  * Git
-  * Go 1.14
-  * MinGW-w64
-  * GNU Make
-  * CMake
-  * Ninja
-  * Python
-
-The easiest way to install all these dependencies is through [Chocolatey](https://chocolatey.org/). Install Chocolatey first, and then run the following command in a command prompt or PowerShell with administrative privileges:
-
-    choco install --confirm git golang mingw make cmake ninja python
-
-Now open a Git Bash window for the remaining steps. The Git Bash window provides a Bash shell with some standard Unix utilities for convenience.
-
-The first thing to do is download the source code:
-
-```shell
-git clone --recursive https://github.com/tinygo-org/tinygo.git
-cd tinygo
-```
-
-Unfortunately there is no way to use a binary release of LLVM to build against (like on Linux and MacOS) so we'll have to build LLVM from scratch. This is a long process which takes at least one hour on most machines.
-
-The following command takes care of downloading and building LLVM. It places the
-source code in `llvm-project/` and the build output in `llvm-build/`. It only needs to
-be done once until the next LLVM release.
-
-```shell
-make llvm-build
-```
-
-Once this is finished, you can build TinyGo against this manually built LLVM:
-
-```shell
-make
-```
-
-This results in a `tinygo.exe` binary in the `build` directory:
-
-```text
-$ ./build/tinygo version
-tinygo version 0.16.0 windows/amd64 (using go version go1.15 and LLVM version 10.0.1)
-```
-
-### Additional Requirements for Microcontrollers
-
-Before anything can be built for a bare-metal target, you need to generate some
-files first:
-
-```shell
-make gen-device
-```
-
-This will generate register descriptions, interrupt vectors, and linker scripts
-for various devices. Also, you may need to re-run this command after updates,
-as some updates cause changes to the generated files.
-
-The same additional requirements to compile TinyGo programs that can run on microcontrollers must be fulfilled when installing TinyGo from source. Please follow [these instructions](#additional-requirements-for-microcontrollers) above.
diff --git a/content/lang-support/_index.md b/content/lang-support/_index.md
deleted file mode 100644
index 037c289c..00000000
--- a/content/lang-support/_index.md
+++ /dev/null
@@ -1,50 +0,0 @@
----
-title: "Go language features"
-weight: 6
----
-
-While TinyGo supports a big subset of the Go language, not everything is supported yet.
-
-Here is a list of features that are supported:
-
-* The subset of Go that directly translates to C is well supported. This includes all basic types and all regular control flow (including `switch`).
-* Slices are well supported.
-* Interfaces are quite stable and should work well in almost all cases. Type switches and type asserts are also supported, as well as calling methods on interfaces. The only exception is comparing two interface values (but comparing against `nil` works).
-* Closures and bound methods are supported, for example inline anonymous (lambda-like) functions.
-* The `defer` keyword is almost entirely supported, with the exception of deferring some builtin functions.
-
-## Concurrency
-
-At the time of writing (2019-11-27), support for goroutines and channels works for the most part. Support for concurrency on ARM microcontrollers is complete but may have some edge cases that don't work. Support for other platforms (such as WebAssembly) is a bit more limited: calling a blocking function may for example allocate heap memory.
-
-## Cgo
-
-While TinyGo embeds the [Clang](https://clang.llvm.org/) compiler to parse `import "C"` blocks, many features of Cgo are still unsupported. For example, `#cgo` statements are only partially supported.
-
-## Reflection
-
-Many packages, especially in the standard library, rely on reflection to work. The `reflect` package has been re-implemented in TinyGo and most common types like numbers, strings, and structs are supported now.
-
-## Maps
-
-Support for maps is not yet complete but is usable. You can use any type as a value, but only some types are acceptable as map keys. Also, they have not been optimized for performance and will cause linear lookup times in some cases.
-
-Types supported as map keys include strings, integers, pointers, and structs/arrays that contain only these types.
-
-## Standard library
-
-Due to the above missing pieces and because parts of the standard library depend on the particular compiler/runtime in use, many packages do not yet compile. See the [list of compiling packages here]({{<ref "stdlib.md">}}) (but note that "compiling" does not imply that works entirely).
-
-## Garbage collection
-
-While not directly a language feature (the Go spec doesn't mention it), garbage collection is important for most Go programs to make sure their memory usage stays in reasonable bounds.
-
-Garbage collection is currently supported on all platforms, although it works best on 32-bit chips. A simple conservative mark-sweep collector is used that will trigger a collection cycle when the heap runs out (that is fixed at compile time) or when requested manually using `runtime.GC()`. Some other collector designs are used for other targets, TinyGo will automatically pick a good GC for a given target.
-
-Careful design may avoid memory allocations in main loops. You may want to compile with `-gc=none` and look at link errors to find out where allocations happen: the compiler inserts calls to `runtime.alloc` to allocate memory. For more information, see [heap allocation]({{<ref "heap-allocation.md">}}).
-
-## A note on the `recover` builtin
-
-The `recover` builtin is not yet supported. Instead, a `panic` will always terminate a program and `recover` simply returns nil.
-
-This is a deviation from the Go spec but so far works well in practice. While there are no immediate plans to implement `recover`, if it can be shown to be necessary for compatibility it will be implemented. Please note that this comes at a cost: it means that every `defer` call will need some extra memory (both code and stack), so this feature is not free. It might also be architecture dependent. If it gets implemented, it will likely be opt-in to not increase code size for existing projects.
diff --git a/content/lang-support/stdlib.md b/content/lang-support/stdlib.md
deleted file mode 100644
index 519650bc..00000000
--- a/content/lang-support/stdlib.md
+++ /dev/null
@@ -1,935 +0,0 @@
-
----
-title: Packages supported by TinyGo
----
-
-The following table shows all Go standard library packages and whether they can be imported by TinyGo. If they can't, you can click the 'no' link to jump to the explanation why the package cannot be compiled.
-
-Note that the fact they can be imported, does not mean that all functions and types in the program can be used. For example, sometimes using some functions or types of the package will still trigger compiler errors.
-
-Package | Importable
---- | --- |
-archive/tar |  [<span style="color: red">✗</span> no](#archive-tar)  | 
-archive/zip |  [<span style="color: red">✗</span> no](#archive-zip)  | 
-bufio |  <span style="color: green">✔</span> yes  | 
-bytes |  <span style="color: green">✔</span> yes  | 
-compress/bzip2 |  <span style="color: green">✔</span> yes  | 
-compress/flate |  <span style="color: green">✔</span> yes  | 
-compress/gzip |  <span style="color: green">✔</span> yes  | 
-compress/lzw |  <span style="color: green">✔</span> yes  | 
-compress/zlib |  <span style="color: green">✔</span> yes  | 
-container/heap |  <span style="color: green">✔</span> yes  | 
-container/list |  <span style="color: green">✔</span> yes  | 
-container/ring |  <span style="color: green">✔</span> yes  | 
-context |  <span style="color: green">✔</span> yes  | 
-crypto |  <span style="color: green">✔</span> yes  | 
-crypto/aes |  <span style="color: green">✔</span> yes  | 
-crypto/cipher |  <span style="color: green">✔</span> yes  | 
-crypto/des |  <span style="color: green">✔</span> yes  | 
-crypto/dsa |  <span style="color: green">✔</span> yes  | 
-crypto/ecdsa |  [<span style="color: red">✗</span> no](#crypto-ecdsa)  | 
-crypto/ed25519 |  <span style="color: green">✔</span> yes  | 
-crypto/elliptic |  <span style="color: green">✔</span> yes  | 
-crypto/hmac |  <span style="color: green">✔</span> yes  | 
-crypto/md5 |  <span style="color: green">✔</span> yes  | 
-crypto/rand |  <span style="color: green">✔</span> yes  | 
-crypto/rc4 |  <span style="color: green">✔</span> yes  | 
-crypto/rsa |  [<span style="color: red">✗</span> no](#crypto-rsa)  | 
-crypto/sha1 |  <span style="color: green">✔</span> yes  | 
-crypto/sha256 |  <span style="color: green">✔</span> yes  | 
-crypto/sha512 |  <span style="color: green">✔</span> yes  | 
-crypto/subtle |  <span style="color: green">✔</span> yes  | 
-crypto/tls |  [<span style="color: red">✗</span> no](#crypto-tls)  | 
-crypto/x509 |  [<span style="color: red">✗</span> no](#crypto-x509)  | 
-crypto/x509/pkix |  [<span style="color: red">✗</span> no](#crypto-x509-pkix)  | 
-database/sql |  <span style="color: green">✔</span> yes  | 
-database/sql/driver |  <span style="color: green">✔</span> yes  | 
-debug/dwarf |  <span style="color: green">✔</span> yes  | 
-debug/elf |  <span style="color: green">✔</span> yes  | 
-debug/gosym |  <span style="color: green">✔</span> yes  | 
-debug/macho |  <span style="color: green">✔</span> yes  | 
-debug/pe |  <span style="color: green">✔</span> yes  | 
-debug/plan9obj |  <span style="color: green">✔</span> yes  | 
-encoding |  <span style="color: green">✔</span> yes  | 
-encoding/ascii85 |  <span style="color: green">✔</span> yes  | 
-encoding/asn1 |  [<span style="color: red">✗</span> no](#encoding-asn1)  | 
-encoding/base32 |  <span style="color: green">✔</span> yes  | 
-encoding/base64 |  <span style="color: green">✔</span> yes  | 
-encoding/binary |  <span style="color: green">✔</span> yes  | 
-encoding/csv |  <span style="color: green">✔</span> yes  | 
-encoding/gob |  [<span style="color: red">✗</span> no](#encoding-gob)  | 
-encoding/hex |  <span style="color: green">✔</span> yes  | 
-encoding/json |  [<span style="color: red">✗</span> no](#encoding-json)  | 
-encoding/pem |  <span style="color: green">✔</span> yes  | 
-encoding/xml |  [<span style="color: red">✗</span> no](#encoding-xml)  | 
-errors |  <span style="color: green">✔</span> yes  | 
-expvar |  [<span style="color: red">✗</span> no](#expvar)  | 
-flag |  <span style="color: green">✔</span> yes  | 
-fmt |  <span style="color: green">✔</span> yes  | 
-go/ast |  <span style="color: green">✔</span> yes  | 
-go/build |  [<span style="color: red">✗</span> no](#go-build)  | 
-go/constant |  <span style="color: green">✔</span> yes  | 
-go/doc |  [<span style="color: red">✗</span> no](#go-doc)  | 
-go/format |  <span style="color: green">✔</span> yes  | 
-go/importer |  [<span style="color: red">✗</span> no](#go-importer)  | 
-go/parser |  <span style="color: green">✔</span> yes  | 
-go/printer |  <span style="color: green">✔</span> yes  | 
-go/scanner |  <span style="color: green">✔</span> yes  | 
-go/token |  <span style="color: green">✔</span> yes  | 
-go/types |  [<span style="color: red">✗</span> no](#go-types)  | 
-hash |  <span style="color: green">✔</span> yes  | 
-hash/adler32 |  <span style="color: green">✔</span> yes  | 
-hash/crc32 |  <span style="color: green">✔</span> yes  | 
-hash/crc64 |  <span style="color: green">✔</span> yes  | 
-hash/fnv |  <span style="color: green">✔</span> yes  | 
-hash/maphash |  <span style="color: green">✔</span> yes  | 
-html |  <span style="color: green">✔</span> yes  | 
-html/template |  [<span style="color: red">✗</span> no](#html-template)  | 
-image |  <span style="color: green">✔</span> yes  | 
-image/color |  <span style="color: green">✔</span> yes  | 
-image/color/palette |  <span style="color: green">✔</span> yes  | 
-image/draw |  <span style="color: green">✔</span> yes  | 
-image/gif |  <span style="color: green">✔</span> yes  | 
-image/jpeg |  <span style="color: green">✔</span> yes  | 
-image/png |  <span style="color: green">✔</span> yes  | 
-index/suffixarray |  <span style="color: green">✔</span> yes  | 
-io |  <span style="color: green">✔</span> yes  | 
-io/ioutil |  <span style="color: green">✔</span> yes  | 
-log |  <span style="color: green">✔</span> yes  | 
-log/syslog |  [<span style="color: red">✗</span> no](#log-syslog)  | 
-math |  <span style="color: green">✔</span> yes  | 
-math/big |  <span style="color: green">✔</span> yes  | 
-math/bits |  <span style="color: green">✔</span> yes  | 
-math/cmplx |  <span style="color: green">✔</span> yes  | 
-math/rand |  <span style="color: green">✔</span> yes  | 
-mime |  <span style="color: green">✔</span> yes  | 
-mime/multipart |  [<span style="color: red">✗</span> no](#mime-multipart)  | 
-mime/quotedprintable |  <span style="color: green">✔</span> yes  | 
-net |  [<span style="color: red">✗</span> no](#net)  | 
-net/http |  [<span style="color: red">✗</span> no](#net-http)  | 
-net/http/cgi |  [<span style="color: red">✗</span> no](#net-http-cgi)  | 
-net/http/cookiejar |  [<span style="color: red">✗</span> no](#net-http-cookiejar)  | 
-net/http/fcgi |  [<span style="color: red">✗</span> no](#net-http-fcgi)  | 
-net/http/httptest |  [<span style="color: red">✗</span> no](#net-http-httptest)  | 
-net/http/httptrace |  [<span style="color: red">✗</span> no](#net-http-httptrace)  | 
-net/http/httputil |  [<span style="color: red">✗</span> no](#net-http-httputil)  | 
-net/http/pprof |  [<span style="color: red">✗</span> no](#net-http-pprof)  | 
-net/mail |  [<span style="color: red">✗</span> no](#net-mail)  | 
-net/rpc |  [<span style="color: red">✗</span> no](#net-rpc)  | 
-net/rpc/jsonrpc |  [<span style="color: red">✗</span> no](#net-rpc-jsonrpc)  | 
-net/smtp |  [<span style="color: red">✗</span> no](#net-smtp)  | 
-net/textproto |  [<span style="color: red">✗</span> no](#net-textproto)  | 
-net/url |  <span style="color: green">✔</span> yes  | 
-os |  <span style="color: green">✔</span> yes  | 
-os/exec |  [<span style="color: red">✗</span> no](#os-exec)  | 
-os/signal |  <span style="color: green">✔</span> yes  | 
-os/user |  [<span style="color: red">✗</span> no](#os-user)  | 
-path |  <span style="color: green">✔</span> yes  | 
-path/filepath |  <span style="color: green">✔</span> yes  | 
-plugin |  <span style="color: green">✔</span> yes  | 
-reflect |  <span style="color: green">✔</span> yes  | 
-regexp |  <span style="color: green">✔</span> yes  | 
-regexp/syntax |  <span style="color: green">✔</span> yes  | 
-sort |  <span style="color: green">✔</span> yes  | 
-strconv |  <span style="color: green">✔</span> yes  | 
-strings |  <span style="color: green">✔</span> yes  | 
-sync |  <span style="color: green">✔</span> yes  | 
-sync/atomic |  <span style="color: green">✔</span> yes  | 
-syscall |  <span style="color: green">✔</span> yes  | 
-syscall/js |  <span style="color: green">✔</span> yes  | 
-testing |  <span style="color: green">✔</span> yes  | 
-testing/iotest |  <span style="color: green">✔</span> yes  | 
-testing/quick |  [<span style="color: red">✗</span> no](#testing-quick)  | 
-text/scanner |  <span style="color: green">✔</span> yes  | 
-text/tabwriter |  <span style="color: green">✔</span> yes  | 
-text/template |  [<span style="color: red">✗</span> no](#text-template)  | 
-text/template/parse |  <span style="color: green">✔</span> yes  | 
-time |  <span style="color: green">✔</span> yes  | 
-time/tzdata |  <span style="color: green">✔</span> yes  | 
-unicode |  <span style="color: green">✔</span> yes  | 
-unicode/utf16 |  <span style="color: green">✔</span> yes  | 
-unicode/utf8 |  <span style="color: green">✔</span> yes  | 
-unsafe |  <span style="color: green">✔</span> yes  | 
-
-
-
-## archive/tar
-
-
-The compiler gave the following error when this package was imported:
-
-<pre># archive/tar
-/home/ron/.gvm/gos/go1.15/src/archive/tar/common.go:554:32: os.FileMode(fi.h.Mode).Perm undefined (type os.FileMode has no field or method Perm)
-/home/ron/.gvm/gos/go1.15/src/archive/tar/common.go:636:15: fi.ModTime undefined (type os.FileInfo has no field or method ModTime)
-/home/ron/.gvm/gos/go1.15/src/archive/tar/common.go:637:21: fm.Perm undefined (type os.FileMode has no field or method Perm)
-/home/ron/.gvm/gos/go1.15/src/archive/tar/common.go:640:10: fm.IsRegular undefined (type os.FileMode has no field or method IsRegular)
-</pre>
-
-
-
-
-
-## archive/zip
-
-
-The compiler gave the following error when this package was imported:
-
-<pre># archive/zip
-/home/ron/.gvm/gos/go1.15/src/archive/zip/struct.go:180:19: fi.ModTime undefined (type os.FileInfo has no field or method ModTime)
-</pre>
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-## crypto/ecdsa
-
-
-The compiler gave the following error when this package was imported:
-
-<pre># encoding/asn1
-encoding/asn1/<init>: interp: unknown GEP
-
-traceback:
-encoding/asn1/<init>:
-  %12 = getelementptr inbounds { %"encoding/asn1.BitString" }, { %"encoding/asn1.BitString" }* %11, i32 0, i32 0, !dbg !1934
-</pre>
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-## crypto/rsa
-
-
-The compiler gave the following error when this package was imported:
-
-<pre># crypto/rsa
-/home/ron/.gvm/gos/go1.15/src/math/big/nat.go:74:11: interp: unknown GEP
-
-traceback:
-/home/ron/.gvm/gos/go1.15/src/math/big/nat.go:74:11:
-  %16 = getelementptr inbounds i32, i32* %4, i32 0, !dbg !1742
-/home/ron/.gvm/gos/go1.15/src/math/big/nat.go:84:19:
-  %9 = call { i32*, i32, i32 } @"(math/big.nat).setWord"(i32* %6, i32 %7, i32 %8, i32 %3, i8* undef, i8* undef), !dbg !1749
-/home/ron/.gvm/gos/go1.15/src/math/big/int.go:55:25:
-  %17 = call { i32*, i32, i32 } @"(math/big.nat).setUint64"(i32* %14, i32 %15, i32 %16, i64 %2, i8* undef, i8* undef), !dbg !1755
-/home/ron/.gvm/gos/go1.15/src/math/big/int.go:69:26:
-  %2 = call %"math/big.Int"* @"(*math/big.Int).SetInt64"(%"math/big.Int"* %0, i64 %x, i8* undef, i8* undef), !dbg !1739
-crypto/rsa/<init>:38:25:
-  %288 = call %"math/big.Int"* @"math/big.NewInt"(i64 0, i8* undef, i8* undef), !dbg !1867
-</pre>
-
-
-
-
-
-
-
-
-
-
-
-
-
-## crypto/tls
-
-
-This package cannot be imported because the following dependencies cannot be compiled:
-
-  * [crypto/ecdsa](#crypto-ecdsa)
-  * [crypto/rsa](#crypto-rsa)
-  * [crypto/x509](#crypto-x509)
-  * [net](#net)
-
-
-
-
-
-## crypto/x509
-
-
-This package cannot be imported because the following dependencies cannot be compiled:
-
-  * [crypto/ecdsa](#crypto-ecdsa)
-  * [crypto/rsa](#crypto-rsa)
-  * [crypto/x509/pkix](#crypto-x509-pkix)
-  * [encoding/asn1](#encoding-asn1)
-  * [net](#net)
-
-
-
-
-
-## crypto/x509/pkix
-
-
-This package cannot be imported because the following dependencies cannot be compiled:
-
-  * [encoding/asn1](#encoding-asn1)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-## encoding/asn1
-
-
-The compiler gave the following error when this package was imported:
-
-<pre># encoding/asn1
-encoding/asn1/<init>: interp: unknown GEP
-
-traceback:
-encoding/asn1/<init>:
-  %12 = getelementptr inbounds { %"encoding/asn1.BitString" }, { %"encoding/asn1.BitString" }* %11, i32 0, i32 0, !dbg !1837
-</pre>
-
-
-
-
-
-
-
-
-
-
-
-
-
-## encoding/gob
-
-
-The compiler gave the following error when this package was imported:
-
-<pre># encoding/gob
-/home/ron/.gvm/gos/go1.15/src/encoding/gob/decode.go:562:21: MakeMapWithSize not declared by package reflect
-/home/ron/.gvm/gos/go1.15/src/encoding/gob/decode.go:948:22: PtrTo not declared by package reflect
-/home/ron/.gvm/gos/go1.15/src/encoding/gob/decode.go:1118:30: srt.FieldByName undefined (type reflect.Type has no field or method FieldByName)
-/home/ron/.gvm/gos/go1.15/src/encoding/gob/encode.go:603:16: PtrTo not declared by package reflect
-/home/ron/.gvm/gos/go1.15/src/encoding/gob/encode.go:643:70: f.Index undefined (type reflect.StructField has no field or method Index)
-/home/ron/.gvm/gos/go1.15/src/encoding/gob/type.go:119:12: cannot convert nil (untyped nil value) to reflect.Type
-/home/ron/.gvm/gos/go1.15/src/encoding/gob/type.go:142:14: PtrTo not declared by package reflect
-/home/ron/.gvm/gos/go1.15/src/encoding/gob/type.go:867:9: rt.PkgPath undefined (type reflect.Type has no field or method PkgPath)
-/home/ron/.gvm/gos/go1.15/src/encoding/gob/type.go:870:21: rt.PkgPath undefined (type reflect.Type has no field or method PkgPath)
-</pre>
-
-
-
-
-
-
-
-## encoding/json
-
-
-The compiler gave the following error when this package was imported:
-
-<pre># encoding/json
-/home/ron/.gvm/gos/go1.15/src/encoding/json/decode.go:160:15: cannot convert nil (untyped nil value) to reflect.Type
-/home/ron/.gvm/gos/go1.15/src/encoding/json/decode.go:232:26: cannot convert nil (untyped nil value) to reflect.Type
-/home/ron/.gvm/gos/go1.15/src/encoding/json/decode.go:249:30: cannot convert nil (untyped nil value) to reflect.Type
-/home/ron/.gvm/gos/go1.15/src/encoding/json/decode.go:515:8: v.NumMethod undefined (type reflect.Value has no field or method NumMethod)
-/home/ron/.gvm/gos/go1.15/src/encoding/json/decode.go:552:7: v.SetLen undefined (type reflect.Value has no field or method SetLen)
-/home/ron/.gvm/gos/go1.15/src/encoding/json/decode.go:589:6: v.SetLen undefined (type reflect.Value has no field or method SetLen)
-/home/ron/.gvm/gos/go1.15/src/encoding/json/decode.go:620:40: v.NumMethod undefined (type reflect.Value has no field or method NumMethod)
-/home/ron/.gvm/gos/go1.15/src/encoding/json/decode.go:641:16: PtrTo not declared by package reflect
-/home/ron/.gvm/gos/go1.15/src/encoding/json/decode.go:776:17: PtrTo not declared by package reflect
-/home/ron/.gvm/gos/go1.15/src/encoding/json/decode.go:921:9: v.NumMethod undefined (type reflect.Value has no field or method NumMethod)
-/home/ron/.gvm/gos/go1.15/src/encoding/json/decode.go:950:6: v.SetBytes undefined (type reflect.Value has no field or method SetBytes)
-/home/ron/.gvm/gos/go1.15/src/encoding/json/decode.go:957:9: v.NumMethod undefined (type reflect.Value has no field or method NumMethod)
-/home/ron/.gvm/gos/go1.15/src/encoding/json/decode.go:990:9: v.NumMethod undefined (type reflect.Value has no field or method NumMethod)
-/home/ron/.gvm/gos/go1.15/src/encoding/json/decode.go:1014:23: v.OverflowFloat undefined (type reflect.Value has no field or method OverflowFloat)
-[...more lines following...]</pre>
-
-
-
-
-
-
-
-## encoding/xml
-
-
-The compiler gave the following error when this package was imported:
-
-<pre># encoding/xml
-/home/ron/.gvm/gos/go1.15/src/encoding/xml/read.go:286:8: val.SetLen undefined (type reflect.Value has no field or method SetLen)
-/home/ron/.gvm/gos/go1.15/src/encoding/xml/read.go:402:6: v.SetLen undefined (type reflect.Value has no field or method SetLen)
-/home/ron/.gvm/gos/go1.15/src/encoding/xml/read.go:665:7: dst.SetBytes undefined (type reflect.Value has no field or method SetBytes)
-/home/ron/.gvm/gos/go1.15/src/encoding/xml/typeinfo.go:114:29: f.Index undefined (type *reflect.StructField has no field or method Index)
-/home/ron/.gvm/gos/go1.15/src/encoding/xml/typeinfo.go:318:14: typ.FieldByIndex undefined (type reflect.Type has no field or method FieldByIndex)
-/home/ron/.gvm/gos/go1.15/src/encoding/xml/typeinfo.go:319:14: typ.FieldByIndex undefined (type reflect.Type has no field or method FieldByIndex)
-</pre>
-
-
-
-
-
-
-
-## expvar
-
-
-This package cannot be imported because the following dependencies cannot be compiled:
-
-  * [encoding/json](#encoding-json)
-  * [net/http](#net-http)
-
-
-
-
-
-
-
-
-
-
-
-## go/build
-
-
-This package cannot be imported because the following dependencies cannot be compiled:
-
-  * [go/doc](#go-doc)
-  * [os/exec](#os-exec)
-
-
-
-
-
-
-
-## go/doc
-
-
-This package cannot be imported because the following dependencies cannot be compiled:
-
-  * [text/template](#text-template)
-
-
-
-
-
-
-
-## go/importer
-
-
-This package cannot be imported because the following dependencies cannot be compiled:
-
-  * [go/build](#go-build)
-  * [go/types](#go-types)
-
-
-
-
-
-
-
-
-
-
-
-
-
-## go/types
-
-
-The compiler gave the following error when this package was imported:
-
-<pre># go/types
-/home/ron/Development/tinygo/tinygo/src/runtime/hashmap.go:203:21: interp: load from a bitcast
-
-traceback:
-/home/ron/Development/tinygo/tinygo/src/runtime/hashmap.go:203:21:
-  %83 = load i8, i8* %82, !dbg !2170
-/home/ron/Development/tinygo/tinygo/src/runtime/hashmap.go:335:19:
-  %13 = call i1 @runtime.hashmapGet(%runtime.hashmap* %m, i8* %12, i8* %value, i32 %valueSize, i32 %11, i8* undef, i32 ptrtoint (%runtime.funcValueWithSignature* @"runtime.hashmapStringEqual$withSignature" to i32), i8* undef, i8* undef), !dbg !2059
-/home/ron/.gvm/gos/go1.15/src/go/types/sizes.go:184:6:
-  %13 = call i1 @runtime.hashmapStringGet(%runtime.hashmap* %9, i8* %11, i32 %12, i8* %hashmap.value.bitcast, i32 4, i8* undef, i8* null), !dbg !2055
-go/types/<init>:202:24:
-  %359 = call %runtime._interface @"go/types.SizesFor"(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @"go/types.init$string.1271", i32 0, i32 0), i32 2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @"go/types.init$string.1272", i32 0, i32 0), i32 5, i8* undef, i8* undef), !dbg !2199
-</pre>
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-## html/template
-
-
-This package cannot be imported because the following dependencies cannot be compiled:
-
-  * [encoding/json](#encoding-json)
-  * [text/template](#text-template)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-## log/syslog
-
-
-This package cannot be imported because the following dependencies cannot be compiled:
-
-  * [net](#net)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-## mime/multipart
-
-
-This package cannot be imported because the following dependencies cannot be compiled:
-
-  * [net/textproto](#net-textproto)
-
-
-
-
-
-
-
-## net
-
-
-The compiler gave the following error when this package was imported:
-
-<pre># net
-/home/ron/.gvm/gos/go1.15/src/net/parse.go:80:12: st.ModTime undefined (type os.FileInfo has no field or method ModTime)
-/home/ron/.gvm/gos/go1.15/src/net/pipe.go:156:16: ErrDeadlineExceeded not declared by package os
-/home/ron/.gvm/gos/go1.15/src/net/pipe.go:169:16: ErrDeadlineExceeded not declared by package os
-/home/ron/.gvm/gos/go1.15/src/net/pipe.go:188:16: ErrDeadlineExceeded not declared by package os
-/home/ron/.gvm/gos/go1.15/src/net/pipe.go:204:17: ErrDeadlineExceeded not declared by package os
-</pre>
-
-
-
-
-
-## net/http
-
-
-This package cannot be imported because the following dependencies cannot be compiled:
-
-  * [crypto/tls](#crypto-tls)
-  * [mime/multipart](#mime-multipart)
-  * [net](#net)
-  * [net/http/httptrace](#net-http-httptrace)
-  * [net/textproto](#net-textproto)
-
-
-
-
-
-## net/http/cgi
-
-
-This package cannot be imported because the following dependencies cannot be compiled:
-
-  * [crypto/tls](#crypto-tls)
-  * [net](#net)
-  * [net/http](#net-http)
-  * [net/textproto](#net-textproto)
-  * [os/exec](#os-exec)
-
-
-
-
-
-## net/http/cookiejar
-
-
-This package cannot be imported because the following dependencies cannot be compiled:
-
-  * [net](#net)
-  * [net/http](#net-http)
-
-
-
-
-
-## net/http/fcgi
-
-
-This package cannot be imported because the following dependencies cannot be compiled:
-
-  * [net](#net)
-  * [net/http](#net-http)
-  * [net/http/cgi](#net-http-cgi)
-
-
-
-
-
-## net/http/httptest
-
-
-This package cannot be imported because the following dependencies cannot be compiled:
-
-  * [crypto/tls](#crypto-tls)
-  * [crypto/x509](#crypto-x509)
-  * [net](#net)
-  * [net/http](#net-http)
-  * [net/textproto](#net-textproto)
-
-
-
-
-
-## net/http/httptrace
-
-
-This package cannot be imported because the following dependencies cannot be compiled:
-
-  * [crypto/tls](#crypto-tls)
-  * [net](#net)
-  * [net/textproto](#net-textproto)
-
-
-
-
-
-## net/http/httputil
-
-
-This package cannot be imported because the following dependencies cannot be compiled:
-
-  * [net](#net)
-  * [net/http](#net-http)
-  * [net/textproto](#net-textproto)
-
-
-
-
-
-## net/http/pprof
-
-
-This package cannot be imported because the following dependencies cannot be compiled:
-
-  * [html/template](#html-template)
-  * [net/http](#net-http)
-
-
-
-
-
-## net/mail
-
-
-This package cannot be imported because the following dependencies cannot be compiled:
-
-  * [net/textproto](#net-textproto)
-
-
-
-
-
-## net/rpc
-
-
-This package cannot be imported because the following dependencies cannot be compiled:
-
-  * [encoding/gob](#encoding-gob)
-  * [html/template](#html-template)
-  * [net](#net)
-  * [net/http](#net-http)
-
-
-
-
-
-## net/rpc/jsonrpc
-
-
-This package cannot be imported because the following dependencies cannot be compiled:
-
-  * [encoding/json](#encoding-json)
-  * [net](#net)
-  * [net/rpc](#net-rpc)
-
-
-
-
-
-## net/smtp
-
-
-This package cannot be imported because the following dependencies cannot be compiled:
-
-  * [crypto/tls](#crypto-tls)
-  * [net](#net)
-  * [net/textproto](#net-textproto)
-
-
-
-
-
-## net/textproto
-
-
-This package cannot be imported because the following dependencies cannot be compiled:
-
-  * [net](#net)
-
-
-
-
-
-
-
-
-
-## os/exec
-
-
-The compiler gave the following error when this package was imported:
-
-<pre># os/exec
-/home/ron/.gvm/gos/go1.15/src/os/exec/exec.go:130:14: Process not declared by package os
-/home/ron/.gvm/gos/go1.15/src/os/exec/exec.go:134:19: ProcessState not declared by package os
-/home/ron/.gvm/gos/go1.15/src/os/exec/exec.go:462:6: ProcessState not declared by package os
-/home/ron/.gvm/gos/go1.15/src/os/exec/exec.go:246:23: DevNull not declared by package os
-/home/ron/.gvm/gos/go1.15/src/os/exec/exec.go:258:20: Pipe not declared by package os
-/home/ron/.gvm/gos/go1.15/src/os/exec/exec.go:291:27: DevNull not declared by package os
-/home/ron/.gvm/gos/go1.15/src/os/exec/exec.go:303:20: Pipe not declared by package os
-/home/ron/.gvm/gos/go1.15/src/os/exec/exec.go:422:22: StartProcess not declared by package os
-/home/ron/.gvm/gos/go1.15/src/os/exec/exec.go:422:57: ProcAttr not declared by package os
-/home/ron/.gvm/gos/go1.15/src/os/exec/exec.go:584:20: Pipe not declared by package os
-/home/ron/.gvm/gos/go1.15/src/os/exec/exec.go:626:20: Pipe not declared by package os
-/home/ron/.gvm/gos/go1.15/src/os/exec/exec.go:651:20: Pipe not declared by package os
-</pre>
-
-
-
-
-
-
-
-## os/user
-
-
-The compiler gave the following error when this package was imported:
-
-<pre># os/user
-/home/ron/.gvm/gos/go1.15/src/os/user/lookup.go:15:41: undeclared name: current
-/home/ron/.gvm/gos/go1.15/src/os/user/lookup.go:36:9: undeclared name: lookupUser
-/home/ron/.gvm/gos/go1.15/src/os/user/lookup.go:45:9: undeclared name: lookupUserId
-/home/ron/.gvm/gos/go1.15/src/os/user/lookup.go:51:9: undeclared name: lookupGroup
-/home/ron/.gvm/gos/go1.15/src/os/user/lookup.go:57:9: undeclared name: lookupGroupId
-/home/ron/.gvm/gos/go1.15/src/os/user/lookup.go:62:9: undeclared name: listGroups
-</pre>
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-## testing/quick
-
-
-The compiler gave the following error when this package was imported:
-
-<pre># testing/quick
-/home/ron/.gvm/gos/go1.15/src/testing/quick/quick.go:273:11: fType.NumOut undefined (type reflect.Type has no field or method NumOut)
-/home/ron/.gvm/gos/go1.15/src/testing/quick/quick.go:276:11: fType.Out undefined (type reflect.Type has no field or method Out)
-/home/ron/.gvm/gos/go1.15/src/testing/quick/quick.go:280:43: fType.NumIn undefined (type reflect.Type has no field or method NumIn)
-/home/ron/.gvm/gos/go1.15/src/testing/quick/quick.go:290:12: fVal.Call undefined (type reflect.Value has no field or method Call)
-/home/ron/.gvm/gos/go1.15/src/testing/quick/quick.go:320:43: xType.NumIn undefined (type reflect.Type has no field or method NumIn)
-/home/ron/.gvm/gos/go1.15/src/testing/quick/quick.go:330:26: x.Call undefined (type reflect.Value has no field or method Call)
-/home/ron/.gvm/gos/go1.15/src/testing/quick/quick.go:331:26: y.Call undefined (type reflect.Value has no field or method Call)
-/home/ron/.gvm/gos/go1.15/src/testing/quick/quick.go:351:25: f.In undefined (type reflect.Type has no field or method In)
-/home/ron/.gvm/gos/go1.15/src/testing/quick/quick.go:353:95: f.In undefined (type reflect.Type has no field or method In)
-</pre>
-
-
-
-
-
-
-
-
-
-## text/template
-
-
-The compiler gave the following error when this package was imported:
-
-<pre># text/template
-/home/ron/.gvm/gos/go1.15/src/text/template/exec.go:377:20: val.Recv undefined (type reflect.Value has no field or method Recv)
-/home/ron/.gvm/gos/go1.15/src/text/template/exec.go:541:25: cannot convert nil (untyped nil value) to reflect.Type
-/home/ron/.gvm/gos/go1.15/src/text/template/exec.go:603:19: ptr.MethodByName undefined (type reflect.Value has no field or method MethodByName)
-/home/ron/.gvm/gos/go1.15/src/text/template/exec.go:610:33: receiver.Type().FieldByName undefined (type reflect.Type has no field or method FieldByName)
-/home/ron/.gvm/gos/go1.15/src/text/template/exec.go:645:21: etyp.FieldByName undefined (type reflect.Type has no field or method FieldByName)
-/home/ron/.gvm/gos/go1.15/src/text/template/exec.go:678:9: typ.IsVariadic undefined (type reflect.Type has no field or method IsVariadic)
-/home/ron/.gvm/gos/go1.15/src/text/template/exec.go:679:18: typ.NumIn undefined (type reflect.Type has no field or method NumIn)
-/home/ron/.gvm/gos/go1.15/src/text/template/exec.go:681:79: typ.NumIn undefined (type reflect.Type has no field or method NumIn)
-/home/ron/.gvm/gos/go1.15/src/text/template/exec.go:683:25: typ.NumIn undefined (type reflect.Type has no field or method NumIn)
-/home/ron/.gvm/gos/go1.15/src/text/template/exec.go:684:69: typ.NumIn undefined (type reflect.Type has no field or method NumIn)
-/home/ron/.gvm/gos/go1.15/src/text/template/exec.go:688:71: typ.NumOut undefined (type reflect.Type has no field or method NumOut)
-/home/ron/.gvm/gos/go1.15/src/text/template/exec.go:695:32: typ.In undefined (type reflect.Type has no field or method In)
-/home/ron/.gvm/gos/go1.15/src/text/template/exec.go:698:9: typ.IsVariadic undefined (type reflect.Type has no field or method IsVariadic)
-/home/ron/.gvm/gos/go1.15/src/text/template/exec.go:699:18: typ.In undefined (type reflect.Type has no field or method In)
-[...more lines following...]</pre>
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/content/media/_index.md b/content/media/_index.md
index 2731fa46..0d6ec90c 100644
--- a/content/media/_index.md
+++ b/content/media/_index.md
@@ -1,69 +1,16 @@
 ---
 title: "Media"
-chapter: true
-weight: 8
+linkTitle: "Media"
+type: "docs"
+menu:
+  main:
+    weight: 40
+description: >
+  Here are some of the videos, podcasts, and blog posts written about TinyGo.
+
+cascade:
+  github_repo: https://github.com/tinygo-org/tinygo-site
+  github_subdir: content/media
+  path_base_for_github_subdir: content/media
+  github_branch: dev
 ---
-
-Here are some of the videos, podcasts, and blog posts written about TinyGo.
-
-### Podcasts/Videos
-
-**QCon 2020 London - "Tiny Go: Small is Going Big"** - *March 3, 2020*
-https://www.infoq.com/presentations/tiny-go/
-
-**FOSDEM 2020 - "Lightning talk: LED cube using TinyGo"** (start at 51:00) - *February 2, 2020*
-https://video.fosdem.org/2020/UB2.252A/golightning.mp4
-
-**FOSDEM 2020 - "TinyGo: Fast, Small, Concurrent: Choose Three"** - *February 2, 2020*
-https://video.fosdem.org/2020/UD2.218A/iottinygo.mp4
-
-**FOSDEM 2020 - "Build real-world gaming hardware with TinyGo"** - *February 2, 2020*
-https://video.fosdem.org/2020/UB2.252A/tinygotoys.mp4
-
-**Gophercon 2019 - "Small is Going Big: Go on Microcontrollers"** - *July 26, 2019*
-https://www.youtube.com/watch?v=EiB9ZVrvrz0
-
-**The Changelog - "Go is eating the world of software"** - *July 25, 2019*
-https://changelog.com/podcast/354
-
-**Go Time - "Hardware hacking with TinyGo and Gopherbot"** - *May 8, 2019*
-https://changelog.com/gotime/84
-
-**dotGo 2019 - "Get Going with WebAssembly"** - *March 25th, 2019*
-https://www.youtube.com/watch?v=osVHH7rjpxs
-
-**FOSDEM 2019 - "Go On Microcontrollers"** - *February 3, 2019*
-https://video.fosdem.org/2019/K.1.105/go_on_microcontrollers.mp4
-
-
-### Blog posts
-
-**Alan Wang - "TinyGo on Arduino Uno: An Introduction"** - *February 5, 2020*
-https://create.arduino.cc/projecthub/alankrantas/tinygo-on-arduino-uno-an-introduction-6130f6
-
-**Arduino - "TinyGo on Arduino"** - *August 23, 2019*
-https://blog.arduino.cc/2019/08/23/tinygo-on-arduino/
-
-**Sourcegraph - "Liveblog - GopherCon 2019 - Small is going big: Go On microcontrollers"** - *July 26, 2019*
-https://about.sourcegraph.com/go/gophercon-2019-small-is-going-big-go-on-microcontrollers
-
-**Ayke van Laëthem - "How the TinyGo playground simulates hardware"** - *July 17, 2019*
-https://aykevl.nl/2019/07/tinygo-plaground-simulator
-
-**Sendil Kumar N - "Reduce your WebAssembly binaries 72% - from 56KB to 26KB to 16KB"** - *July 7, 2019*
-https://dev.to/sendilkumarn/reduce-your-webassembly-binaries-72-from-56kb-to-26kb-to-16kb-40mi
-
-**Sendil Kumar N - "(Tiny)Go to WebAssembly"** - *July 5, 2019*
-https://dev.to/sendilkumarn/tiny-go-to-webassembly-5168
-
-**Adafruit - "Using tinyGo on an Adafruit ItsyBitsy M0 board"** - *June 7, 2019*
-https://blog.adafruit.com/2019/06/07/using-tinggo-on-an-adafruit-itsybitsy-m0-board-golang-tinygo-microcontrollers-adafruit-adafruit-deadprogram-tinggolang/
-
-**Ayke van Laëthem - "LLVM from a Go perspective"** - *April 28, 2019*
-https://aykevl.nl/2019/04/llvm-from-go
-
-**Adafruit - "TinyGo – Go on Microcontrollers runs on Adafruit Circuit Playground Express"** - *March 12, 2019*
-https://blog.adafruit.com/2019/03/12/tinygo-go-on-microcontrollers-tinygolang-tinygo-runs-on-adafruit-circuit-playground-express/
-
-**Ayke van Laëthem - "Goroutines in TinyGo"** - *February 25, 2019*
-https://aykevl.nl/2019/02/tinygo-goroutines
diff --git a/content/media/articles.md b/content/media/articles.md
new file mode 100644
index 00000000..8665e434
--- /dev/null
+++ b/content/media/articles.md
@@ -0,0 +1,52 @@
+---
+title: "Articles"
+linkTitle: "Articles"
+type: "docs"
+weight: 45
+description: >
+  Articles and blog posts talking about TinyGo
+---
+**Hriday Keni - "TinyGo for Embedded Applications: Coding Without the Code-Phobia"** - *February 1, 2025*
+https://medium.com/@hrkeni/tinygo-for-embedded-applications-coding-without-the-code-phobia-28ed90b5bcb0
+
+**Eric Gregory - "Compile Go directly to WebAssembly components with TinyGo and WASI P2"** - *July 2, 2024*
+https://wasmcloud.com/blog/compile-go-directly-to-webassembly-components-with-tinygo-and-wasi-p2/
+
+**Matt Butcher - "4 Big Developments in WebAssembly"** - *April 18, 2024*
+https://thenewstack.io/4-big-developments-in-webassembly/
+
+**Pragmatik.tech - Multiple articles on TinyGo and Raspberry Pi Pico** - *July 2022 onwards*
+https://pragmatik.tech/tags/tinygo/
+
+**Aurélie Vache - "Learning Go by examples: part 5 - Create a Game Boy Advance (GBA) game in Go"** - *August 11, 2021*
+https://dev.to/aurelievache/learning-go-by-examples-part-5-create-a-game-boy-advance-gba-game-in-go-5944
+
+**Alan Wang - "TinyGo on Arduino Uno: An Introduction"** - *February 5, 2020*
+https://create.arduino.cc/projecthub/alankrantas/tinygo-on-arduino-uno-an-introduction-6130f6
+
+**Arduino - "TinyGo on Arduino"** - *August 23, 2019*
+https://blog.arduino.cc/2019/08/23/tinygo-on-arduino/
+
+**Sourcegraph - "Liveblog - GopherCon 2019 - Small is going big: Go On microcontrollers"** - *July 26, 2019*
+https://about.sourcegraph.com/go/gophercon-2019-small-is-going-big-go-on-microcontrollers
+
+**Ayke van Laëthem - "How the TinyGo playground simulates hardware"** - *July 17, 2019*
+https://aykevl.nl/2019/07/tinygo-plaground-simulator
+
+**Sendil Kumar N - "Reduce your WebAssembly binaries 72% - from 56KB to 26KB to 16KB"** - *July 7, 2019*
+https://dev.to/sendilkumarn/reduce-your-webassembly-binaries-72-from-56kb-to-26kb-to-16kb-40mi
+
+**Sendil Kumar N - "(Tiny)Go to WebAssembly"** - *July 5, 2019*
+https://dev.to/sendilkumarn/tiny-go-to-webassembly-5168
+
+**Adafruit - "Using tinyGo on an Adafruit ItsyBitsy M0 board"** - *June 7, 2019*
+https://blog.adafruit.com/2019/06/07/using-tinggo-on-an-adafruit-itsybitsy-m0-board-golang-tinygo-microcontrollers-adafruit-adafruit-deadprogram-tinggolang/
+
+**Ayke van Laëthem - "LLVM from a Go perspective"** - *April 28, 2019*
+https://aykevl.nl/2019/04/llvm-from-go
+
+**Adafruit - "TinyGo – Go on Microcontrollers runs on Adafruit Circuit Playground Express"** - *March 12, 2019*
+https://blog.adafruit.com/2019/03/12/tinygo-go-on-microcontrollers-tinygolang-tinygo-runs-on-adafruit-circuit-playground-express/
+
+**Ayke van Laëthem - "Goroutines in TinyGo"** - *February 25, 2019*
+https://aykevl.nl/2019/02/tinygo-goroutines
diff --git a/content/media/video.md b/content/media/video.md
new file mode 100644
index 00000000..0717252b
--- /dev/null
+++ b/content/media/video.md
@@ -0,0 +1,75 @@
+---
+title: "Video"
+linkTitle: "Video"
+type: "docs"
+weight: 35
+description: >
+  Videos/Podcasts talking about TinyGo
+---
+
+**FOSDEM 2025 - Ron Evans - "Return To Go Without Wires"** - *February 8, 2025*
+https://cuddly.tube/w/pkw3cCH4NFbTht7vHttChg
+
+**FOSDEM 2025 - Daniel Esteban - "Playing games without a computer: Hardware fun with TinyGo"** - *February 8, 2025*
+https://cuddly.tube/w/2UGxR1utDVN8S6vcyW64rB
+
+**FOSDEM 2025 - Ayke van Laethem - "Implementing parallelism: how we added threading and multicore support in TinyGo"** - *February 8, 2025*
+https://cuddly.tube/w/32DjftoiTssyT1tPyjxr1w
+
+**GoLab 2024 - Josephine Winter - "TinyGo for Pet Automation"** - *November 13, 2024*
+https://www.youtube.com/watch?v=CmSohy0CNdk
+
+**GopherCon US 2024 - Patricio Whittingslow - "Go in the Smallest of Places"** - *July 10, 2024*
+https://www.youtube.com/watch?v=CQJJ6KS-PF4
+
+**FOSDEM 2024 - Ayke van Laethem - "Smartwatch firmware... in Go? On TinyGo, small displays, and building a delightful developer experience"** - *February 3, 2024*
+https://video.fosdem.org/2024/ud2218a/fosdem-2024-2562-smartwatch-firmware-in-go-on-tinygo-small-displays-and-building-a-delightful-developer-experience.av1.webm
+
+**FOSDEM 2024 - Ron Evans - "Go Without Wires Strikes Back"** - *February 3, 2024*
+https://video.fosdem.org/2024/ud2218a/fosdem-2024-2270-go-without-wires-strikes-back.av1.webm
+
+**FOSDEM 2023 - Ron Evans - Go Even Further Without Wires** - *February 4, 2023*
+https://video.fosdem.org/2023/UD2.218A/goevenfurtherwithoutwires.mp4
+
+**FOSDEM 2023 - Daniel Esteban - Visually programming Go** - *February 4, 2023*
+https://video.fosdem.org/2023/UD2.218A/govisuallyprogramming.mp4
+
+**GopherCon US 2022 - Donia Chaiehloudj - TinyGo: Getting the Upper Hen** - *October 8, 2022*
+https://www.youtube.com/watch?v=D46NzhBoQC0
+
+**Pragmatik.tech - Charath Ranganathan - Multiple videos on TinyGo and Raspberry Pi Pico** - *July 2022 onwards*
+https://www.youtube.com/channel/UChxDHx-FThGJscOn3ljTi6A
+
+**CALM - Thierry Chantier - "TinyGo sur Pygamer" [FR]** - *June 15, 2021*
+https://www.youtube.com/watch?v=FI0_tC6ESJA&t=694s
+
+**Microsoft LearnTV - "Hello World"** - *June 15, 2021*
+https://channel9.msdn.com/Shows/Hello-World/Hello-World-Tuesday-June-15-2021#time=03m09s
+
+**QCon 2020 London - "Tiny Go: Small is Going Big"** - *March 3, 2020*
+https://www.infoq.com/presentations/tiny-go/
+
+**FOSDEM 2020 - "Lightning talk: LED cube using TinyGo"** (start at 51:00) - *February 2, 2020*
+https://video.fosdem.org/2020/UB2.252A/golightning.mp4
+
+**FOSDEM 2020 - "TinyGo: Fast, Small, Concurrent: Choose Three"** - *February 2, 2020*
+https://video.fosdem.org/2020/UD2.218A/iottinygo.mp4
+
+**FOSDEM 2020 - "Build real-world gaming hardware with TinyGo"** - *February 2, 2020*
+https://video.fosdem.org/2020/UB2.252A/tinygotoys.mp4
+
+**Gophercon 2019 - "Small is Going Big: Go on Microcontrollers"** - *July 26, 2019*
+https://www.youtube.com/watch?v=EiB9ZVrvrz0
+
+**The Changelog - "Go is eating the world of software"** - *July 25, 2019*
+https://changelog.com/podcast/354
+
+**Go Time - "Hardware hacking with TinyGo and Gopherbot"** - *May 8, 2019*
+https://changelog.com/gotime/84
+
+**dotGo 2019 - "Get Going with WebAssembly"** - *March 25th, 2019*
+https://www.youtube.com/watch?v=osVHH7rjpxs
+
+**FOSDEM 2019 - "Go On Microcontrollers"** - *February 3, 2019*
+https://video.fosdem.org/2019/K.1.105/go_on_microcontrollers.mp4
+
diff --git a/content/microcontrollers/_index.md b/content/microcontrollers/_index.md
deleted file mode 100644
index ef5f6119..00000000
--- a/content/microcontrollers/_index.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: "Go on microcontrollers"
-chapter: true
-weight: 3
----
-
-# Go on microcontrollers
-
-TinyGo lets you run Go directly on microcontrollers.
-
-TinyGo has support for 48 different boards and devices such as the Arduino Nano33 IoT, Adafruit Circuit Playground Express, BBC micro:bit and more. Click on a board name found in the left menu to see the what features are supported for the given hardware.
-
-We also give you the ability to add new boards. If your target isn't listed here, please raise an issue in the [issue tracker](https://github.com/tinygo-org/tinygo/issues).
-
-Want to know the details about how it is possible to compile Go for microcontrollers? Check out the [microcontrollers](../compiler-internals/microcontrollers/) page in our "Compiler Internals" section.
diff --git a/content/microcontrollers/arduino-mega2560.md b/content/microcontrollers/arduino-mega2560.md
deleted file mode 100644
index ef6fdb45..00000000
--- a/content/microcontrollers/arduino-mega2560.md
+++ /dev/null
@@ -1,50 +0,0 @@
----
-title: "Arduino Mega 2560"
-weight: 3
----
-
-The [Arduino Mega 2560](https://store.arduino.cc/arduino-mega-2560-rev3) is based on the AVR [ATmega2560](https://www.microchip.com/wwwproducts/en/ATmega2560) microcontroller.
-
-Note: the AVR backend of LLVM is still experimental so you may encounter bugs.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | Not yet |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Arduino Mega 2560](../machine/arduino-mega2560)
-
-## Installing dependencies
-
-The Arduino Mega 2560 needs a few extra dependencies to work, for example, if you get an error like this:
-
-```text
-/usr/lib/gcc/avr/5.4.0/../../../avr/bin/ld: cannot find -lm
-/usr/lib/gcc/avr/5.4.0/../../../avr/bin/ld: cannot find -lc
-collect2: error: ld returned 1 exit status
-```
-
-Or like this:
-
-```text
-/bin/sh: 1: avrdude: not found
-```
-
-To fix this, see the installation guide for [Linux](../../getting-started/linux/#avr-arduino) and for [macOS](../../getting-started/macos/#avr-arduino).
-
-## Flashing
-
-### AVRDude
-
-Programs are loaded onto the Arduino Mega 2560 using the `avrdude` command line utility program. You must install this program before you will be able to flash the Arduino Uno board with your TinyGo code.
-
-- Plug your Arduino Uno into your computer's USB port.
-- Build and flash your TinyGo program using `tinygo flash -target arduino-mega2560 /path/to/code`
diff --git a/content/microcontrollers/arduino-nano.md b/content/microcontrollers/arduino-nano.md
deleted file mode 100644
index a4a34f90..00000000
--- a/content/microcontrollers/arduino-nano.md
+++ /dev/null
@@ -1,50 +0,0 @@
----
-title: "Arduino Nano"
-weight: 3
----
-
-The [Arduino Nano](https://store.arduino.cc/arduino-nano) is based on the AVR [ATmega328p](https://www.microchip.com/wwwproducts/en/ATmega328p) microcontroller.
-
-Note: the AVR backend of LLVM is still experimental so you may encounter bugs.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | Not yet |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Arduino Nano](../machine/arduino-nano)
-
-## Installing dependencies
-
-The Arduino Nano needs a few extra dependencies to work, for example, if you get an error like this:
-
-```text
-/usr/lib/gcc/avr/5.4.0/../../../avr/bin/ld: cannot find -lm
-/usr/lib/gcc/avr/5.4.0/../../../avr/bin/ld: cannot find -lc
-collect2: error: ld returned 1 exit status
-```
-
-Or like this:
-
-```text
-/bin/sh: 1: avrdude: not found
-```
-
-To fix this, see the installation guide for [Linux](../../getting-started/linux/#avr-arduino) and for [macOS](../../getting-started/macos/#avr-arduino).
-
-## Flashing
-
-### AVRDude
-
-Programs are loaded onto the Arduino Uno using the `avrdude` command line utility program. You must install this program before you will be able to flash the Arduino Uno board with your TinyGo code.
-
-- Plug your Arduino Uno into your computer's USB port.
-- Build and flash your TinyGo program using `tinygo flash -target=arduino-nano`
diff --git a/content/microcontrollers/arduino-nano33-iot.md b/content/microcontrollers/arduino-nano33-iot.md
deleted file mode 100644
index 70052510..00000000
--- a/content/microcontrollers/arduino-nano33-iot.md
+++ /dev/null
@@ -1,109 +0,0 @@
----
-title: "Arduino Nano33 IoT"
-weight: 3
----
-
-The [Arduino Nano33 IoT](https://store.arduino.cc/nano-33-iot) is a very small ARM development board based on the Atmel [SAMD21](https://www.microchip.com/wwwproducts/en/ATSAMD21G18) family of processors. It also has a NINA-W102 chip onboard which provides an wireless communication abilities based on the popular ESP32 family of wireless chips from Espressif.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Arduino Nano33 IoT](../machine/arduino-nano33)
-
-## Pin Mapping
-
-Since the pin labels are located on the other side of the board, here is a picture showing the pin numbering from the front side perspective:
-
-![Arduino Nano33 IoT](../../images/nano33pinmap.jpg)
-
-## Installing BOSSA
-
-In order to flash your TinyGo programs onto the Arduino Nano33 IoT board, you will need to install the "bossac" command line utility which is part of the [BOSSA command line utilities](https://github.com/shumatech/BOSSA).
-
-### macOS
-
-You can use Homebrew to install the BOSSA command line interface by using the following command:
-
-```shell
-brew cask install bossa
-```
-
-Or if you  prefer, you can also download the installer from https://github.com/shumatech/BOSSA/releases/download/1.9.1/bossa-1.9.1.dmg
-
-Once you have downloaded it, double click on the .dmg file to perform the installation.
-
-### Linux
-
-On Linux, install from source:
-
-```shell
-sudo apt install libreadline-dev libwxgtk3.0-* 
-git clone https://github.com/shumatech/BOSSA.git
-cd BOSSA
-make
-sudo cp bin/bossac /usr/local/bin
-```
-
-### Windows
-
-You can download BOSSA from https://github.com/shumatech/BOSSA/releases/download/1.9.1/bossa-x64-1.9.1.msi
-
-*VERY IMPORTANT*: During the installation, you much choose to install into `c:\Program Files`. The installer might have the wrong path, so edit it to match  `c:\Program Files`.
-
-After the installation, you must add BOSSA to your PATH:
-
-```shell
-set PATH=%PATH%;"c:\Program Files\BOSSA";
-```
-
-Test that you have installed "BOSSA" correctly by running this command:
-
-```shell
-bossac --help
-```
-
-## Flashing
-
-Once you have installed the needed BOSSA command line utility, as in the previous section, you are ready to build and flash code to your Arduino Nano33 IoT board.
-
-### CLI Flashing
-
-- Plug your Arduino Nano33 IoT board into your computer's USB port.
-- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the Arduino Nano33 IoT with the blinky1 example:
-
-    ```
-    tinygo flash -target=arduino-nano33 examples/blinky1
-    ```
-
-- The Arduino Nano33 IoT board should restart and then begin running your program.
-
-### Troubleshooting
-
-If you have troubles getting your Arduino Nano33 IoTboard to receive code, try this:
-
-- Press the "RESET" button on the board two times to get the Arduino Nano33 IoT board ready to receive code.
-- Now try running the `tinygo flash` command as above:
-
-    ```shell
-    tinygo flash -target=arduino-nano33 [PATH TO YOUR PROGRAM]
-    ```
-
-Once you have updated your Arduino Nano33 IoT board the first time, after that you should be able to flash it entirely from the command line.
-
-## Notes
-
-You can use the USB port to the Arduino Nano33 IoT as a serial port. `UART0` refers to this connection.
-
-For information on how to use the built-in NINA-W102 wireless chip with the default firmware, please see the "wifinina" driver in the TinyGo drivers repository located at [https://github.com/tinygo-org/drivers/tree/release/wifinina](https://github.com/tinygo-org/drivers/tree/release/wifinina).
-
-You can also use the Espressif ESP-AT firmware, although you will need to flash it yourself. Please see the "espat" driver in the TinyGo drivers repository located at [https://github.com/tinygo-org/drivers/tree/release/espat](https://github.com/tinygo-org/drivers/tree/release/espat).
diff --git a/content/microcontrollers/arduino-uno.md b/content/microcontrollers/arduino-uno.md
deleted file mode 100644
index 3ae9fcbf..00000000
--- a/content/microcontrollers/arduino-uno.md
+++ /dev/null
@@ -1,50 +0,0 @@
----
-title: "Arduino Uno"
-weight: 3
----
-
-The [Arduino Uno](https://store.arduino.cc/arduino-uno-rev3) is based on the AVR [ATmega328p](https://www.microchip.com/wwwproducts/en/ATmega328p) microcontroller.
-
-Note: the AVR backend of LLVM is still experimental so you may encounter bugs.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | Not yet |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Arduino Uno](../machine/arduino)
-
-## Installing dependencies
-
-The Arduino Uno needs a few extra dependencies to work, for example, if you get an error like this:
-
-```text
-/usr/lib/gcc/avr/5.4.0/../../../avr/bin/ld: cannot find -lm
-/usr/lib/gcc/avr/5.4.0/../../../avr/bin/ld: cannot find -lc
-collect2: error: ld returned 1 exit status
-```
-
-Or like this:
-
-```text
-/bin/sh: 1: avrdude: not found
-```
-
-To fix this, see the installation guide for [Linux](../../getting-started/linux/#avr-arduino) and for [macOS](../../getting-started/macos/#avr-arduino).
-
-## Flashing
-
-### AVRDude
-
-Programs are loaded onto the Arduino Uno using the `avrdude` command line utility program. You must install this program before you will be able to flash the Arduino Uno board with your TinyGo code.
-
-- Plug your Arduino Uno into your computer's USB port.
-- Build and flash your TinyGo program using `tinygo flash -target arduino /path/to/code`
diff --git a/content/microcontrollers/arduino-zero.md b/content/microcontrollers/arduino-zero.md
deleted file mode 100644
index 0772fe08..00000000
--- a/content/microcontrollers/arduino-zero.md
+++ /dev/null
@@ -1,100 +0,0 @@
----
-title: "Arduino Zero"
-weight: 3
----
-
-The [Arduino Zero](https://store.arduino.cc/arduino-zero) is a very small ARM development board based on the Atmel [SAMD21](https://www.microchip.com/wwwproducts/en/ATSAMD21G18) family of processors.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Arduino Zero](../machine/arduino-zero)
-
-## Installing BOSSA
-
-In order to flash your TinyGo programs onto the Arduino Zero board, you will need to install the "bossac" command line utility which is part of the [BOSSA command line utilities](https://github.com/shumatech/BOSSA).
-
-### macOS
-
-You can use Homebrew to install the BOSSA command line interface by using the following command:
-
-```shell
-brew cask install bossa
-```
-
-Or if you  prefer, you can also download the installer from https://github.com/shumatech/BOSSA/releases/download/1.9.1/bossa-1.9.1.dmg
-
-Once you have downloaded it, double click on the .dmg file to perform the installation.
-
-### Linux
-
-On Linux, install from source:
-
-```shell
-sudo apt install libreadline-dev libwxgtk3.0-* 
-git clone https://github.com/shumatech/BOSSA.git
-cd BOSSA
-make
-sudo cp bin/bossac /usr/local/bin
-```
-
-### Windows
-
-You can download BOSSA from https://github.com/shumatech/BOSSA/releases/download/1.9.1/bossa-x64-1.9.1.msi
-
-*VERY IMPORTANT*: During the installation, you much choose to install into `c:\Program Files`. The installer might have the wrong path, so edit it to match  `c:\Program Files`.
-
-After the installation, you must add BOSSA to your PATH:
-
-```shell
-set PATH=%PATH%;"c:\Program Files\BOSSA";
-```
-
-Test that you have installed "BOSSA" correctly by running this command:
-
-```shell
-bossac --help
-```
-
-## Flashing
-
-Once you have installed the needed BOSSA command line utility, as in the previous section, you are ready to build and flash code to your Arduino Zero board.
-
-### CLI Flashing
-
-- Plug your Arduino Zero board into your computer's USB port.
-- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the Arduino Zero with the blinky1 example:
-
-    ```
-    tinygo flash -target=arduino-zero examples/blinky1
-    ```
-
-- The Arduino Zero board should restart and then begin running your program.
-
-
-### Troubleshooting
-
-If you have troubles getting your Arduino Zero board to receive code, try this:
-
-- Press the "RESET" button on the board two times to get the Arduino Zero board ready to receive code.
-- Now try running the `tinygo flash` command as above:
-
-    ```shell
-    tinygo flash -target=arduino-zero [PATH TO YOUR PROGRAM]
-    ```
-
-Once you have updated your Arduino Zero board the first time, after that you should be able to flash it entirely from the command line.
-
-## Notes
-
-You can use the USB port to the Arduino Zero as a serial port. `UART0` refers to this connection.
diff --git a/content/microcontrollers/bluepill.md b/content/microcontrollers/bluepill.md
deleted file mode 100644
index 5b392c8b..00000000
--- a/content/microcontrollers/bluepill.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "Bluepill"
-weight: 3
----
-
-The [Bluepill](http://wiki.stm32duino.com/index.php?title=Blue_Pill) is a popular, ultra-cheap and compact ARM development board based on the ST Micro [STM32F103C8](https://www.st.com/en/microcontrollers/stm32f103c8.html) SoC.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | Not yet |
-| PWM      | YES | Not yet |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Bluepill](../machine/bluepill)
-
-## Flashing
-
-### OpenOCD
-
-Programs are loaded onto the Bluepill with a separate hardware programmer such as the [STLink v2](https://www.st.com/en/development-tools/st-link-v2.html) board, using the `openocd` command line utility program to perform the board flashing. You must install [OpenOCD](http://openocd.org/) before you will be able to flash the Bluepill board with your TinyGo code.
-
-- Plug your STLink v2 programmer into your computer's USB port.
-- Plug your Bluepill into the STLink v2 programmer using the Bluepill `SWIO`, `SWCLK`, `3V3` and `GND` pins.
-- Build and flash your TinyGo program using `tinygo flash -target=bluepill`
diff --git a/content/microcontrollers/circuit-playground-bluefruit.md b/content/microcontrollers/circuit-playground-bluefruit.md
deleted file mode 100644
index e3c318ef..00000000
--- a/content/microcontrollers/circuit-playground-bluefruit.md
+++ /dev/null
@@ -1,62 +0,0 @@
----
-title: "Adafruit Circuit Playground Bluefruit"
-weight: 3
----
-
-The [Adafruit Circuit Playground Bluefruit](https://www.adafruit.com/product/4333) is small ARM development board based on the Nordic Semiconductor [nrf52840](https://www.nordicsemi.com/eng/Products/nRF52840) processor. It has several built-in devices such as WS2812 "NeoPixel" LEDs, buttons, an accelerometer, and some other sensors.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
-| Bluetooth      | YES | YES |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Circuit Playground Bluefruit](../machine/circuitplay-bluefruit)
-
-## Flashing
-
-### UF2
-
-The Circuit Playground Bluefruit comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
-
-### CLI Flashing
-
-- Plug your Circuit Playground Bluefruit into your computer's USB port.
-- Flash your TinyGo program to the board using this command:
-
-    ```shell
-    tinygo flash -target=circuitplay-bluefruit [PATH TO YOUR PROGRAM]
-    ```
-
-- The Circuit Playground Bluefruit board should restart and then begin running your program.
-
-### Troubleshooting
-
-If you have troubles getting your Circuit Playground Bluefruit board to receive code, try this:
-
-- Press the "RESET" button on the board two times to get the Circuit Playground Bluefruit board ready to receive code.
-- The Circuit Playground Bluefruit board will appear to your computer like a USB drive.
-- Now try running the command:
-
-    ```shell
-    tinygo flash -target=circuitplay-bluefruit [PATH TO YOUR PROGRAM]
-    ```
-
-Once you have updated your Circuit Playground Bluefruit board the first time, after that you should be able to flash it entirely from the command line.
-
-## Notes
-
-You can use the USB port to the Circuit Playground Bluefruit as a serial port. `UART0` refers to this connection.
-
-For an example that uses the built-in Neopixel LEDs, take a look at the TinyGo drivers repository located at [https://github.com/tinygo-org/drivers/tree/release/examples](https://github.com/tinygo-org/drivers)
-
-Bluetooth support is now available for the Circuit Playground Bluefruit board. See https://github.com/tinygo-org/bluetooth for more information.
-
diff --git a/content/microcontrollers/circuit-playground-express.md b/content/microcontrollers/circuit-playground-express.md
deleted file mode 100644
index 002a2864..00000000
--- a/content/microcontrollers/circuit-playground-express.md
+++ /dev/null
@@ -1,58 +0,0 @@
----
-title: "Adafruit Circuit Playground Express"
-weight: 3
----
-
-The [Adafruit Circuit Playground Express](https://www.adafruit.com/product/3333) is small ARM development board based on the Atmel [SAMD21](https://www.microchip.com/wwwproducts/en/ATSAMD21G18) family of processors. It has several built-in devices such as WS2812 "NeoPixel" LEDs, buttons, an accelerometer, and some other sensors.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Circuit Playground Express](../machine/circuitplay-express)
-
-## Flashing
-
-### UF2
-
-The Circuit Playground Express comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
-
-### CLI Flashing
-
-- Plug your Circuit Playground Express into your computer's USB port.
-- Flash your TinyGo program to the board using this command:
-
-    ```shell
-    tinygo flash -target=circuitplay-express [PATH TO YOUR PROGRAM]
-    ```
-
-- The Circuit Playground Express board should restart and then begin running your program.
-
-### Troubleshooting
-
-If you have troubles getting your Circuit Playground Express board to receive code, try this:
-
-- Press the "RESET" button on the board two times to get the Circuit Playground Express board ready to receive code.
-- The Circuit Playground Express board will appear to your computer like a USB drive.
-- Now try running the command:
-
-    ```shell
-    tinygo flash -target=circuitplay-express [PATH TO YOUR PROGRAM]
-    ```
-
-Once you have updated your Circuit Playground Express board the first time, after that you should be able to flash it entirely from the command line.
-
-## Notes
-
-You can use the USB port to the Circuit Playground Express as a serial port. `UART0` refers to this connection.
-
-For an example that uses the built-in Neopixel LEDs, take a look at the TinyGo drivers repository located at [https://github.com/tinygo-org/drivers/tree/release/examples](https://github.com/tinygo-org/drivers)
diff --git a/content/microcontrollers/clue-alpha.md b/content/microcontrollers/clue-alpha.md
deleted file mode 100644
index daa4bab3..00000000
--- a/content/microcontrollers/clue-alpha.md
+++ /dev/null
@@ -1,61 +0,0 @@
----
-title: "Adafruit CLUE"
-weight: 3
----
-
-The [Adafruit CLUE](https://www.adafruit.com/product/4500) is small ARM development board based on the Nordic Semiconductor [nrf52840](https://www.nordicsemi.com/eng/Products/nRF52840) processor. It has several built-in devices such as WS2812 "NeoPixel" LEDs, buttons, an accelerometer, and some other sensors.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
-| Bluetooth      | YES | YES |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Adafruit CLUE](../machine/clue-alpha)
-
-## Flashing
-
-### UF2
-
-The CLUE comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
-
-### CLI Flashing
-
-- Plug your CLUE into your computer's USB port.
-- Flash your TinyGo program to the board using this command:
-
-    ```shell
-    tinygo flash -target=clue-alpha [PATH TO YOUR PROGRAM]
-    ```
-
-- The CLUE board should restart and then begin running your program.
-
-### Troubleshooting
-
-If you have troubles getting your CLUE board to receive code, try this:
-
-- Press the "RESET" button on the board two times to get the CLUE board ready to receive code.
-- The CLUE board will appear to your computer like a USB drive.
-- Now try running the command:
-
-    ```shell
-    tinygo flash -target=clue-alpha [PATH TO YOUR PROGRAM]
-    ```
-
-Once you have updated your CLUE board the first time, after that you should be able to flash it entirely from the command line.
-
-## Notes
-
-You can use the USB port to the CLUE as a serial port. `UART0` refers to this connection.
-
-For an example that uses the built-in Neopixel LEDs, take a look at the TinyGo drivers repository located at [https://github.com/tinygo-org/drivers/tree/release/examples](https://github.com/tinygo-org/drivers)
-
-Bluetooth support is now available for the Adafruit CLUE board. See https://github.com/tinygo-org/bluetooth for more information.
diff --git a/content/microcontrollers/drivers/_index.md b/content/microcontrollers/drivers/_index.md
deleted file mode 100644
index da58ab12..00000000
--- a/content/microcontrollers/drivers/_index.md
+++ /dev/null
@@ -1,71 +0,0 @@
----
-title: "Drivers"
-chapter: true
-weight: 90
----
-
-# Drivers
-
-TinyGo has driver support for 53 different sensors and devices such as digital accelerometers and multicolor LEDs.
-
-All of the drivers code is in the TinyGo Drivers repository located at [https://github.com/tinygo-org/drivers/](https://github.com/tinygo-org/drivers/).
-
-The following 53 devices are supported.
-
-| Device Name | Interface Type |
-|----------|-------------|
-| [ADT7410 I2C Temperature Sensor](https://www.analog.com/media/en/technical-documentation/data-sheets/ADT7410.pdf) | I2C |
-| [ADXL345 accelerometer](http://www.analog.com/media/en/technical-documentation/data-sheets/ADXL345.pdf) | I2C |
-| [AMG88xx 8x8 Thermal camera sensor](https://cdn-learn.adafruit.com/assets/assets/000/043/261/original/Grid-EYE_SPECIFICATIONS%28Reference%29.pdf) | I2C |
-| [APA102 RGB LED](https://cdn-shop.adafruit.com/product-files/2343/APA102C.pdf) | SPI |
-| [AT24CX 2-wire serial EEPROM](https://www.openimpulse.com/blog/wp-content/uploads/wpsc/downloadables/24C32-Datasheet.pdf) | I2C |
-| [BBC micro:bit LED matrix](https://github.com/bbcmicrobit/hardware/blob/master/SCH_BBC-Microbit_V1.3B.pdf) | GPIO |
-| [BH1750 ambient light sensor](https://www.mouser.com/ds/2/348/bh1750fvi-e-186247.pdf) | I2C |
-| [BlinkM RGB LED](http://thingm.com/fileadmin/thingm/downloads/BlinkM_datasheet.pdf) | I2C |
-| [BME280 humidity/pressure sensor](https://cdn-shop.adafruit.com/datasheets/BST-BME280_DS001-10.pdf) | I2C |
-| [BMI160 accelerometer/gyroscope](https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmi160-ds000.pdf) | SPI |
-| [BMP180 barometer](https://cdn-shop.adafruit.com/datasheets/BST-BMP180-DS000-09.pdf) | I2C |
-| [BMP280 temperature/barometer](https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp280-ds001.pdf) | I2C |
-| [Buzzer](https://en.wikipedia.org/wiki/Buzzer#Piezoelectric) | GPIO |
-| [DS1307 real time clock](https://datasheets.maximintegrated.com/en/ds/DS1307.pdf) | I2C |
-| [DS3231 real time clock](https://datasheets.maximintegrated.com/en/ds/DS3231.pdf) | I2C |
-| [ESP32 as WiFi Coprocessor with Arduino nina-fw](https://github.com/arduino/nina-fw) | SPI |
-| [ESP8266/ESP32 AT Command set for WiFi/TCP/UDP](https://github.com/espressif/esp32-at) | UART |
-| [GPS module](https://www.u-blox.com/en/product/neo-6-series) | I2C/UART |
-| [HC-SR04 Ultrasonic distance sensor](https://cdn.sparkfun.com/datasheets/Sensors/Proximity/HCSR04.pdf) | GPIO |
-| [HD44780 LCD controller](https://www.sparkfun.com/datasheets/LCD/HD44780.pdf) | GPIO/I2C |
-| [HUB75 RGB led matrix](https://cdn-learn.adafruit.com/downloads/pdf/32x16-32x32-rgb-led-matrix.pdf) | SPI |
-| [ILI9341 TFT color display](https://cdn-shop.adafruit.com/datasheets/ILI9341.pdf) | SPI |
-| [L293x motor driver](https://www.ti.com/lit/ds/symlink/l293d.pdf) | GPIO/PWM |
-| [L9110x motor driver](https://www.elecrow.com/download/datasheet-l9110.pdf) | GPIO/PWM |
-| [LIS2MDL magnetometer](https://www.st.com/resource/en/datasheet/lis2mdl.pdf) | I2C |
-| [LIS3DH accelerometer](https://www.st.com/resource/en/datasheet/lis3dh.pdf) | I2C |
-| [LSM6DS3 accelerometer](https://www.st.com/resource/en/datasheet/lsm6ds3.pdf) | I2C |
-| [MAG3110 magnetometer](https://www.nxp.com/docs/en/data-sheet/MAG3110.pdf) | I2C |
-| [MCP3008 analog to digital converter (ADC)](http://ww1.microchip.com/downloads/en/DeviceDoc/21295d.pdf) | SPI |
-| [Microphone - PDM](https://cdn-learn.adafruit.com/assets/assets/000/049/977/original/MP34DT01-M.pdf) | I2S/PDM |
-| [MMA8653 accelerometer](https://www.nxp.com/docs/en/data-sheet/MMA8653FC.pdf) | I2C |
-| [MPU6050 accelerometer/gyroscope](https://store.invensense.com/datasheets/invensense/MPU-6050_DataSheet_V3%204.pdf) | I2C |
-| [PCD8544 display](http://eia.udg.edu/~forest/PCD8544_1.pdf) | SPI |
-| [Resistive Touchscreen (4-wire)](http://ww1.microchip.com/downloads/en/Appnotes/doc8091.pdf) | GPIO |
-| [Semihosting](https://wiki.segger.com/Semihosting) | Debug |
-| [Shift register (PISO)](https://en.wikipedia.org/wiki/Shift_register#Parallel-in_serial-out_\(PISO\)) | GPIO |
-| [Shift registers (SIPO)](https://en.wikipedia.org/wiki/Shift_register#Serial-in_parallel-out_(SIPO)) | GPIO |
-| [SHT3x Digital Humidity Sensor](https://www.sensirion.com/fileadmin/user_upload/customers/sensirion/Dokumente/0_Datasheets/Humidity/Sensirion_Humidity_Sensors_SHT3x_Datasheet_digital.pdf) | I2C |
-| [SPI NOR Flash Memory](https://en.wikipedia.org/wiki/Flash_memory#NOR_flash) | SPI/QSPI |
-| [SSD1306 OLED display](https://cdn-shop.adafruit.com/datasheets/SSD1306.pdf) | I2C / SPI |
-| [SSD1331 TFT color display](https://www.crystalfontz.com/controllers/SolomonSystech/SSD1331/381/) | SPI |
-| [SSD1351 OLED display](https://download.mikroe.com/documents/datasheets/ssd1351-revision-1.3.pdf) | SPI |
-| [ST7735 TFT color display](https://www.crystalfontz.com/controllers/Sitronix/ST7735R/319/) | SPI |
-| [ST7789 TFT color display](https://cdn-shop.adafruit.com/product-files/3787/3787_tft_QT154H2201__________20190228182902.pdf) | SPI |
-| [Stepper motor "Easystepper" controller](https://en.wikipedia.org/wiki/Stepper_motor) | GPIO |
-| [Thermistor](https://www.farnell.com/datasheets/33552.pdf) | ADC |
-| [TMP102 I2C Temperature Sensor](https://download.mikroe.com/documents/datasheets/tmp102-data-sheet.pdf) | I2C |
-| [VEML6070 UV light sensor](https://www.vishay.com/docs/84277/veml6070.pdf) | I2C |
-| [VL53L1X time-of-flight distance sensor](https://www.st.com/resource/en/datasheet/vl53l1x.pdf) | I2C |
-| [Waveshare 2.13" (B & C) e-paper display](https://www.waveshare.com/w/upload/d/d3/2.13inch-e-paper-b-Specification.pdf) | SPI |
-| [Waveshare 2.13" e-paper display](https://www.waveshare.com/w/upload/e/e6/2.13inch_e-Paper_Datasheet.pdf) | SPI |
-| [Waveshare 4.2" e-paper B/W display](https://www.waveshare.com/w/upload/6/6a/4.2inch-e-paper-specification.pdf) | SPI |
-| [WS2812 RGB LED](https://cdn-shop.adafruit.com/datasheets/WS2812.pdf) | GPIO |
-
-We also give you the ability to add new drivers. If your device isn't listed here, please raise an issue in the [issue tracker](https://github.com/tinygo-org/drivers/issues).
diff --git a/content/microcontrollers/esp32-coreboard-v2.md b/content/microcontrollers/esp32-coreboard-v2.md
deleted file mode 100644
index 3aef58b8..00000000
--- a/content/microcontrollers/esp32-coreboard-v2.md
+++ /dev/null
@@ -1,96 +0,0 @@
----
-title: "ESP32 - Core board"
-weight: 3
----
-
-The esp32-coreboard-v2 is a development board based on the [Espressif ESP32](https://www.espressif.com/en/products/socs/esp32) a powerful chip that is used on many different board mostly because of the built-in radio that can be used for WiFi or Bluetooth wireless connections.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | Not Yet |
-| ADC      | YES | Not Yet |
-| PWM      | YES | Not Yet |
-| WiFi      | YES | Not Yet |
-| Bluetooth      | YES | Not Yet |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the ESP32 Core board v2](../machine/esp32-coreboard-v2)
-
-## Flashing
-
-### CLI Flashing on Linux
-
-You need to install the Espressif toolchain for Linux to use TinyGo with the ESP32: 
-
-https://docs.espressif.com/projects/esp-idf/en/release-v3.0/get-started/linux-setup.html#standard-setup-of-toolchain-for-linux
-
-In addition, you must install the `esptool` flashing tool:
-
-https://github.com/espressif/esptool#easy-installation
-
-Now you should be able to flash your board as follows:
-
-- Plug your ESP32 board into your computer's USB port.
-- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the ESP32 with the blinky1 example:
-
-    ```
-    tinygo flash -target=esp32-coreboard-v2 -port=/dev/ttyUSB0 examples/blinky1
-    ```
-
-- The ESP32 board should restart and then begin running your program.
-
-### CLI Flashing on macOS
-
-You need to install the Espressif toolchain for macOS to use TinyGo with the ESP32: 
-
-https://docs.espressif.com/projects/esp-idf/en/release-v3.0/get-started/macos-setup.html
-
-In addition, you must install the `esptool` flashing tool:
-
-https://github.com/espressif/esptool#easy-installation
-
-Now you should be able to flash your board as follows:
-
-- Plug your ESP32 board into your computer's USB port.
-- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the ESP32 with the blinky1 example:
-
-    ```
-    tinygo flash -target=esp32-coreboard-v2 examples/blinky1
-    ```
-
-- The ESP32 board should restart and then begin running your program.
-
-### CLI Flashing on Windows
-
-You need to install the Espressif toolchain for Windows to use TinyGo with the ESP32: 
-
-https://docs.espressif.com/projects/esp-idf/en/release-v3.0/get-started/windows-setup.html
-
-In addition, you must install the `esptool` flashing tool:
-
-https://github.com/espressif/esptool#easy-installation
-
-Now you should be able to flash your board as follows:
-
-- Plug your ESP32 board into your computer's USB port.
-- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the ESP32 with the blinky1 example:
-
-    ```
-    tinygo flash -target=esp32-coreboard-v2 examples/blinky1
-    ```
-
-- The ESP32 board should restart and then begin running your program.
-
-### Troubleshooting
-
-Goes here
-
-## Notes
-
-Goes here
diff --git a/content/microcontrollers/esp32-mini32.md b/content/microcontrollers/esp32-mini32.md
deleted file mode 100644
index 832815ba..00000000
--- a/content/microcontrollers/esp32-mini32.md
+++ /dev/null
@@ -1,96 +0,0 @@
----
-title: "ESP32 - mini32"
-weight: 3
----
-
-The mini32 is a small development board based on the popular [Espressif ESP32](https://www.espressif.com/en/products/socs/esp32). The ESP32 includes a built-in radio that can be used for WiFi or Bluetooth wireless connections.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | Not Yet |
-| ADC      | YES | Not Yet |
-| PWM      | YES | Not Yet |
-| WiFi      | YES | Not Yet |
-| Bluetooth      | YES | Not Yet |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the ESP32-mini32](../machine/esp32-mini32)
-
-## Flashing
-
-### CLI Flashing on Linux
-
-You need to install the Espressif toolchain for Linux to use TinyGo with the ESP32: 
-
-https://docs.espressif.com/projects/esp-idf/en/release-v3.0/get-started/linux-setup.html#standard-setup-of-toolchain-for-linux
-
-In addition, you must install the `esptool` flashing tool:
-
-https://github.com/espressif/esptool#easy-installation
-
-Now you should be able to flash your board as follows:
-
-- Plug your ESP32 board into your computer's USB port.
-- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the ESP32 with the blinky1 example:
-
-    ```
-    tinygo flash -target=esp32-mini32 -port=/dev/ttyUSB0 examples/blinky1
-    ```
-
-- The ESP32 board should restart and then begin running your program.
-
-### CLI Flashing on macOS
-
-You need to install the Espressif toolchain for macOS to use TinyGo with the ESP32: 
-
-https://docs.espressif.com/projects/esp-idf/en/release-v3.0/get-started/macos-setup.html
-
-In addition, you must install the `esptool` flashing tool:
-
-https://github.com/espressif/esptool#easy-installation
-
-Now you should be able to flash your board as follows:
-
-- Plug your ESP32 board into your computer's USB port.
-- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the ESP32 with the blinky1 example:
-
-    ```
-    tinygo flash -target=esp32-mini32 examples/blinky1
-    ```
-
-- The ESP32 board should restart and then begin running your program.
-
-### CLI Flashing on Windows
-
-You need to install the Espressif toolchain for Windows to use TinyGo with the ESP32: 
-
-https://docs.espressif.com/projects/esp-idf/en/release-v3.0/get-started/windows-setup.html
-
-In addition, you must install the `esptool` flashing tool:
-
-https://github.com/espressif/esptool#easy-installation
-
-Now you should be able to flash your board as follows:
-
-- Plug your ESP32 board into your computer's USB port.
-- Build and flash your TinyGo code using the `tinygo flash` command. This command flashes the ESP32 with the blinky1 example:
-
-    ```
-    tinygo flash -target=esp32-mini32 examples/blinky1
-    ```
-
-- The ESP32 board should restart and then begin running your program.
-
-### Troubleshooting
-
-Goes here
-
-## Notes
-
-Goes here
diff --git a/content/microcontrollers/feather-m0.md b/content/microcontrollers/feather-m0.md
deleted file mode 100644
index 40cdea2c..00000000
--- a/content/microcontrollers/feather-m0.md
+++ /dev/null
@@ -1,57 +0,0 @@
----
-title: "Adafruit Feather M0"
-weight: 3
----
-
-The [Adafruit Feather M0](https://www.adafruit.com/product/3403) is a tiny ARM development board based on the Atmel [ATSAMD21G18](https://www.microchip.com/wwwproducts/en/ATSAMD21G18) family of SoC.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Adafruit Feather M0](../machine/feather-m0)
-
-## Flashing
-
-### UF2
-
-The Feather M0 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
-
-### CLI Flashing
-
-- Plug your Feather M0 into your computer's USB port.
-- Flash your TinyGo program to the board using this command:
-
-    ```shell
-    tinygo flash -target=feather-m0 [PATH TO YOUR PROGRAM]
-    ```
-
-- The Feather M0 board should restart and then begin running your program.
-
-### Troubleshooting
-
-If you have troubles getting your Feather M0 board to receive code, try this:
-
-- Press the "RESET" button on the board two times to get the Feather M0 board ready to receive code.
-- The Feather M0 board will appear to your computer like a USB drive.
-- Now try running the command as above:
-
-
-```shell
-tinygo flash -target=feather-m0 [PATH TO YOUR PROGRAM]
-```
-
-Once you have updated your Feather M0 board the first time, after that you should be able to flash it entirely from the command line.
-
-## Notes
-
-You can use the USB port to the Feather M0 as a serial port. `UART0` refers to this connection.
diff --git a/content/microcontrollers/feather-m4.md b/content/microcontrollers/feather-m4.md
deleted file mode 100644
index bd28de84..00000000
--- a/content/microcontrollers/feather-m4.md
+++ /dev/null
@@ -1,58 +0,0 @@
----
-title: "Adafruit Feather M4"
-weight: 3
----
-
-The [Adafruit Feather M4](https://www.adafruit.com/product/3857) is a tiny ARM development board based on the Atmel [ATSAMD51J19](https://www.microchip.com/wwwproducts/en/ATSAMD51J19A) family of SoC.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Adafruit Feather M4](../machine/feather-m4)
-
-## Flashing
-
-### UF2
-
-The Feather M4 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
-
-### CLI Flashing
-
-- Plug your Feather M4 into your computer's USB port.
-- Flash your TinyGo program to the board using this command:
-
-    ```shell
-    tinygo flash -target=feather-m4 [PATH TO YOUR PROGRAM]
-    ```
-
-- The Feather M4 board should restart and then begin running your program.
-
-
-### Troubleshooting
-
-If you have troubles getting your Feather M4 board to receive code, try this:
-
-- Press the "RESET" button on the board two times to get the Feather M4 board ready to receive code.
-- The Feather M4 board will appear to your computer like a USB drive.
-- Now try running the command as above:
-
-
-```shell
-tinygo flash -target=feather-m4 [PATH TO YOUR PROGRAM]
-```
-
-Once you have updated your Feather M4 board the first time, after that you should be able to flash it entirely from the command line.
-
-## Notes
-
-You can use the USB port to the Feather M4 as a serial port. `UART0` refers to this connection.
diff --git a/content/microcontrollers/feather-nrf52840.md b/content/microcontrollers/feather-nrf52840.md
deleted file mode 100644
index 73551ba1..00000000
--- a/content/microcontrollers/feather-nrf52840.md
+++ /dev/null
@@ -1,59 +0,0 @@
----
-title: "Adafruit Feather nRF52840"
-weight: 3
----
-
-The [Adafruit Feather nRF52840](https://www.adafruit.com/product/4500) is a small ARM development board based on the Nordic Semiconductor [nrf52840](https://www.nordicsemi.com/eng/Products/nRF52840) processor.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
-| Bluetooth      | YES | YES |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Adafruit Feather nRF52840](../machine/feather-nrf52840)
-
-## Flashing
-
-### UF2
-
-The Adafruit Feather nRF52840 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
-
-### CLI Flashing
-
-- Plug your Adafruit Feather nRF52840 into your computer's USB port.
-- Flash your TinyGo program to the board using this command:
-
-    ```shell
-    tinygo flash -target=feather-nrf52840 [PATH TO YOUR PROGRAM]
-    ```
-
-- The Adafruit Feather nRF52840 board should restart and then begin running your program.
-
-### Troubleshooting
-
-If you have troubles getting your Adafruit Feather nRF52840 board to receive code, try this:
-
-- Press the "RESET" button on the board two times to get the Adafruit Feather nRF52840 board ready to receive code.
-- The Adafruit Feather nRF52840 board will appear to your computer like a USB drive.
-- Now try running the command:
-
-    ```shell
-    tinygo flash -target=feather-nrf52840 [PATH TO YOUR PROGRAM]
-    ```
-
-Once you have updated your Adafruit Feather nRF52840 board the first time, after that you should be able to flash it entirely from the command line.
-
-## Notes
-
-You can use the USB port to the Adafruit Feather nRF52840 as a serial port. `UART0` refers to this connection.
-
-Bluetooth support is now available for the Adafruit Feather nRF52840 board. See https://github.com/tinygo-org/bluetooth for more information.
diff --git a/content/microcontrollers/feather-stm32f405.md b/content/microcontrollers/feather-stm32f405.md
deleted file mode 100644
index daa4bcdf..00000000
--- a/content/microcontrollers/feather-stm32f405.md
+++ /dev/null
@@ -1,56 +0,0 @@
----
-title: "Adafruit Feather STM32F405"
-weight: 3
----
-
-The [Adafruit Feather STM32F405](https://www.adafruit.com/product/4382) is a tiny ARM development board based on the ST Micro [STM32F405](https://www.st.com/resource/en/datasheet/dm00037051.pdf) family of microcontrollers.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | Not yet |
-| PWM      | YES | Not yet |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Adafruit Feather STM32F405](../machine/feather-stm32f405)
-
-## Flashing
-
-Flashing this board using its DFU bootloader can be a bit cumbersome (see Adafruit docs at https://learn.adafruit.com/adafruit-stm32f405-feather-express/dfu-bootloader-details), but it is possible - without requiring an external programmer - by pulling the B0 pin high (you can use the board's 3.3V output pin) at bootup when connected to host PC via USB. This puts the device in bootloader mode.
-
-Once in bootloader mode, the device can be programmed using the open-source tool `dfu-util`.
-
-### CLI Flashing on Linux
-
-You must first install the `dfu-util` program in order to flash the Adafruit Feather STM32F405 board.
-
-    sudo apt update 
-    sudo apt install dfu-util
-
-### CLI Flashing on macOS
-
-You must first install the `dfu-util` program in order to flash the Adafruit Feather STM32F405 board. You can do this using Homebrew on macOS:
-
-    brew install dfu-util
-
-### CLI Flashing on Windows
-
-You must first install the `dfu-util` program in order to flash the Adafruit Feather STM32F405 board.
-
-- Download dfu-util from the website here: http://dfu-util.sourceforge.net/releases/dfu-util-0.9-win64.zip
-- Decompress the files to a directory such as `C:\dfu-util`
-- Add `C:\dfu-util` to your `PATH`.
-
-### Troubleshooting
-
-If you run into trouble getting dfu-util installed and working on Windows, see the blog post at https://www.hanselman.com/blog/HowToFixDfuutilSTMWinUSBZadigBootloadersAndOtherFirmwareFlashingIssuesOnWindows.aspx
-
-## Notes
-
-Goes here
diff --git a/content/microcontrollers/gameboy-advance.md b/content/microcontrollers/gameboy-advance.md
deleted file mode 100644
index ddc10eaa..00000000
--- a/content/microcontrollers/gameboy-advance.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: "Game Boy Advance"
-weight: 3
----
-
-The [Game Boy Advance](https://en.wikipedia.org/wiki/Game_Boy_Advance) is a handheld videogame platform based on the [ARM7TDMI](http://infocenter.arm.com/help/topic/com.arm.doc.ddi0210c/DDI0210B.pdf) microcontroller.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | ? | ? |
-| UART      | ? | ? |
-| SPI      | ? | ? |
-| I2C      | ? | ? |
-| ADC      | ? | ? |
-| PWM      | ? | ? |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Gameboy Advance](../machine/gameboy-advance)
-
-## Installing dependencies
-
-You can use a Game Boy Advance software emulator such as MGBA (https://mgba.io) to test your programs.
-
-
-## Building code
-
-Build your Game Boy Advance programs using `-target gameboy-advance` like this:
-
-```shell
-tinygo build -o main.gba -target gameboy-advance examples/gba-display
-```
-
-You can now use the GBA file with your emulator or flash it onto your physical hardware.
-
-## Flashing
-
-Information needed here...
diff --git a/content/microcontrollers/hifive1b.md b/content/microcontrollers/hifive1b.md
deleted file mode 100644
index 40fbe033..00000000
--- a/content/microcontrollers/hifive1b.md
+++ /dev/null
@@ -1,39 +0,0 @@
----
-title: "HiFive1 RevB"
-weight: 3
----
-
-The [HiFive1 Rev B](https://www.sifive.com/boards/hifive1-rev-b) is low-cost, Arduino-compatible development board featuring the [Freedom E310](https://www.sifive.com/chip-designer#fe310) 320+ MHz [RISC-V](https://riscv.org/) chip.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | Write only |
-| I2C      | YES | YES |
-| ADC      | NO | NO |
-| PWM      | YES | Not yet |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the SiFive HiFive1b](../machine/hifive1b)
-
-## Flashing
-
-### MSD Flashing
-
-The HiFive1 RevB comes with a bootloader that allows Mass Storage Device (MSD) flashing. This means you can just copy the compiled `.hex` file generated by TinyGo onto it, no additional flashing software is needed.
-
-- Plug your HiFive1 RevB into your computer's USB port.
-
-- The HiFive1 RevB board will appear to your computer like a USB drive.
-
-- Build and flash your TinyGo program using `tinygo flash` like this:
-
-    ```shell
-    tinygo flash -target=hifive1b [PATH TO YOUR PROGRAM]
-    ```
-
-- The HiFive1 RevB should restart and begin running your program.
diff --git a/content/microcontrollers/itsybitsy-m0.md b/content/microcontrollers/itsybitsy-m0.md
deleted file mode 100644
index 6b49fe1f..00000000
--- a/content/microcontrollers/itsybitsy-m0.md
+++ /dev/null
@@ -1,56 +0,0 @@
----
-title: "Adafruit ItsyBitsy M0"
-weight: 3
----
-
-The [Adafruit ItsyBitsy M0](https://www.adafruit.com/product/3727) is very compact ARM development board based on the Atmel [SAMD21](https://www.microchip.com/wwwproducts/en/ATSAMD21G18) family of SoC.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Adafruit ItsyBitsy M0](../machine/itsybitsy-m0)
-
-## Flashing
-
-### UF2
-
-The ItsyBitsy M0 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
-
-### CLI Flashing
-
-- Plug your ItsyBitsy M0 into your computer's USB port.
-- Flash your TinyGo program to the board using this command:
-
-    ```shell
-    tinygo flash -target=itsybitsy-m0 [PATH TO YOUR PROGRAM]
-    ```
-
-- The ItsyBitsy M0 board should restart and then begin running your program.
-
-### Troubleshooting
-
-If you have troubles getting your ItsyBitsy M0 board to receive code, try this:
-
-- Press the "RESET" button on the board two times to get the ItsyBitsy M0 board ready to receive code.
-- The ItsyBitsy M0 board will appear to your computer like a USB drive.
-- Now try running the command:
-
-    ```shell
-    tinygo flash -target=itsybitsy-m0 [PATH TO YOUR PROGRAM]
-    ```
-
-Once you have updated your ItsyBitsy M0 board the first time, after that you should be able to flash it entirely from the command line.
-
-## Notes
-
-You can use the USB port to the ItsyBitsy M0 as a serial port. `UART0` refers to this connection.
diff --git a/content/microcontrollers/itsybitsy-m4.md b/content/microcontrollers/itsybitsy-m4.md
deleted file mode 100644
index 411c9282..00000000
--- a/content/microcontrollers/itsybitsy-m4.md
+++ /dev/null
@@ -1,56 +0,0 @@
----
-title: "Adafruit ItsyBitsy M4"
-weight: 3
----
-
-The [Adafruit ItsyBitsy M4](https://www.adafruit.com/product/3800) is very compact ARM development board based on the Atmel [SAMD51](https://www.microchip.com/wwwproducts/en/ATSAMD51G19A) family of SoC.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Adafruit ItsyBitsy M4](../machine/itsybitsy-m4)
-
-## Flashing
-
-### UF2
-
-The ItsyBitsy M4 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
-
-### CLI Flashing
-
-- Plug your ItsyBitsy M4 into your computer's USB port.
-- Flash your TinyGo program to the board using this command:
-
-    ```shell
-    tinygo flash -target=itsybitsy-m4 [PATH TO YOUR PROGRAM]
-    ```
-
-- The ItsyBitsy M4 board should restart and then begin running your program.
-
-### Troubleshooting
-
-If you have troubles getting your ItsyBitsy M4 board to receive code, try this:
-
-- Press the "RESET" button on the board two times to get the ItsyBitsy M4 board ready to receive code.
-- The ItsyBitsy M4 board will appear to your computer like a USB drive.
-- Now try running the command as above:
-
-    ```shell
-    tinygo flash -target=itsybitsy-m4 [PATH TO YOUR PROGRAM]
-    ```
-
-Once you have updated your ItsyBitsy M4 board the first time, after that you should be able to flash it entirely from the command line.
-
-## Notes
-
-You can use the USB port to the ItsyBitsy M4 as a serial port. `UART0` refers to this connection.
diff --git a/content/microcontrollers/itsybitsy-nrf52840.md b/content/microcontrollers/itsybitsy-nrf52840.md
deleted file mode 100644
index 7c880d64..00000000
--- a/content/microcontrollers/itsybitsy-nrf52840.md
+++ /dev/null
@@ -1,61 +0,0 @@
----
-title: "Adafruit ItsyBitsy-nRF52840"
-weight: 3
----
-
-The [Adafruit ItsyBitsy-nRF52840](https://www.adafruit.com/product/4333) is a small ARM development board based on the Nordic Semiconductor [nrf52840](https://www.nordicsemi.com/eng/Products/nRF52840)  processor.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
-| Bluetooth      | YES | YES |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the ItsyBitsy-nRF52840](../machine/itsybitsy-nrf52840)
-
-## Flashing
-
-### UF2
-
-The ItsyBitsy-nRF52840 comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
-
-### CLI Flashing
-
-- Plug your ItsyBitsy-nRF52840 into your computer's USB port.
-- Flash your TinyGo program to the board using this command:
-
-    ```shell
-    tinygo flash -target=itsybitsy-nrf52840 [PATH TO YOUR PROGRAM]
-    ```
-
-- The ItsyBitsy-nRF52840 board should restart and then begin running your program.
-
-### Troubleshooting
-
-If you have troubles getting your ItsyBitsy-nRF52840 board to receive code, try this:
-
-- Press the "RESET" button on the board two times to get the ItsyBitsy-nRF52840 board ready to receive code.
-- The ItsyBitsy-nRF52840 board will appear to your computer like a USB drive.
-- Now try running the command:
-
-    ```shell
-    tinygo flash -target=itsybitsy-nrf52840 [PATH TO YOUR PROGRAM]
-    ```
-
-Once you have updated your ItsyBitsy-nRF52840 board the first time, after that you should be able to flash it entirely from the command line.
-
-## Notes
-
-You can use the USB port to the ItsyBitsy-nRF52840 as a serial port. `UART0` refers to this connection.
-
-For an example that uses the built-in Neopixel LEDs, take a look at the TinyGo drivers repository located at [https://github.com/tinygo-org/drivers/tree/release/examples](https://github.com/tinygo-org/drivers)
-
-Bluetooth support is now available for the ItsyBitsy-nRF52840 board. See https://github.com/tinygo-org/bluetooth for more information.
diff --git a/content/microcontrollers/machine/arduino-mega2560.md b/content/microcontrollers/machine/arduino-mega2560.md
deleted file mode 100644
index 82916f0d..00000000
--- a/content/microcontrollers/machine/arduino-mega2560.md
+++ /dev/null
@@ -1,664 +0,0 @@
-
----
-title: arduino-mega2560
----
-
-
-## Constants
-
-```go
-const (
-	AREF	Pin	= NoPin
-	LED	Pin	= PB7
-
-	A0	Pin	= PF0
-	A1	Pin	= PF1
-	A2	Pin	= PF2
-	A3	Pin	= PF3
-	A4	Pin	= PF4
-	A5	Pin	= PF5
-	A6	Pin	= PF6
-	A7	Pin	= PF7
-	A8	Pin	= PK0
-	A9	Pin	= PK1
-	A10	Pin	= PK2
-	A11	Pin	= PK3
-	A12	Pin	= PK4
-	A13	Pin	= PK5
-	A14	Pin	= PK6
-	A15	Pin	= PK7
-
-	// Analog Input
-	ADC0	Pin	= PF0
-	ADC1	Pin	= PF1
-	ADC2	Pin	= PF2
-	ADC3	Pin	= PF3
-	ADC4	Pin	= PF4
-	ADC5	Pin	= PF5
-	ADC6	Pin	= PF6
-	ADC7	Pin	= PF7
-	ADC8	Pin	= PK0
-	ADC9	Pin	= PK1
-	ADC10	Pin	= PK2
-	ADC11	Pin	= PK3
-	ADC12	Pin	= PK4
-	ADC13	Pin	= PK5
-	ADC14	Pin	= PK6
-	ADC15	Pin	= PK7
-
-	// Digital pins
-	D0	Pin	= PE0
-	D1	Pin	= PE1
-	D2	Pin	= PE4
-	D3	Pin	= PE5
-	D4	Pin	= PG5
-	D5	Pin	= PE3
-	D6	Pin	= PH3
-	D7	Pin	= PH4
-	D8	Pin	= PH5
-	D9	Pin	= PH6
-	D10	Pin	= PB4
-	D11	Pin	= PB5
-	D12	Pin	= PB6
-	D13	Pin	= PB7
-	D14	Pin	= PJ1
-	D15	Pin	= PJ0
-	D16	Pin	= PH1
-	D17	Pin	= PH0
-	D18	Pin	= PD3
-	D19	Pin	= PD2
-	D20	Pin	= PD1
-	D21	Pin	= PD0
-	D22	Pin	= PA0
-	D23	Pin	= PA1
-	D24	Pin	= PA2
-	D25	Pin	= PA3
-	D26	Pin	= PA4
-	D27	Pin	= PA5
-	D28	Pin	= PA6
-	D29	Pin	= PA7
-	D30	Pin	= PC7
-	D31	Pin	= PC6
-	D32	Pin	= PC5
-	D33	Pin	= PC4
-	D34	Pin	= PC3
-	D35	Pin	= PC2
-	D36	Pin	= PC1
-	D37	Pin	= PC0
-	D38	Pin	= PD7
-	D39	Pin	= PG2
-	D40	Pin	= PG1
-	D41	Pin	= PG0
-	D42	Pin	= PL7
-	D43	Pin	= PL6
-	D44	Pin	= PL5
-	D45	Pin	= PL4
-	D46	Pin	= PL3
-	D47	Pin	= PL2
-	D48	Pin	= PL1
-	D49	Pin	= PL0
-	D50	Pin	= PB3
-	D51	Pin	= PB2
-	D52	Pin	= PB1
-	D53	Pin	= PB0
-)
-```
-
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PA0	= portA + 0
-	PA1	= portA + 1
-	PA2	= portA + 2
-	PA3	= portA + 3
-	PA4	= portA + 4
-	PA5	= portA + 5
-	PA6	= portA + 6
-	PA7	= portA + 7
-	PB0	= portB + 0
-	PB1	= portB + 1
-	PB2	= portB + 2
-	PB3	= portB + 3
-	PB4	= portB + 4
-	PB5	= portB + 5
-	PB6	= portB + 6
-	PB7	= portB + 7
-	PC0	= portC + 0
-	PC1	= portC + 1
-	PC2	= portC + 2
-	PC3	= portC + 3
-	PC4	= portC + 4
-	PC5	= portC + 5
-	PC6	= portC + 6
-	PC7	= portC + 7
-	PD0	= portD + 0
-	PD1	= portD + 1
-	PD2	= portD + 2
-	PD3	= portD + 3
-	PD7	= portD + 7
-	PE0	= portE + 0
-	PE1	= portE + 1
-	PE3	= portE + 3
-	PE4	= portE + 4
-	PE5	= portE + 5
-	PE6	= portE + 6
-	PF0	= portF + 0
-	PF1	= portF + 1
-	PF2	= portF + 2
-	PF3	= portF + 3
-	PF4	= portF + 4
-	PF5	= portF + 5
-	PF6	= portF + 6
-	PF7	= portF + 7
-	PG0	= portG + 0
-	PG1	= portG + 1
-	PG2	= portG + 2
-	PG5	= portG + 5
-	PH0	= portH + 0
-	PH1	= portH + 1
-	PH3	= portH + 3
-	PH4	= portH + 4
-	PH5	= portH + 5
-	PH6	= portH + 6
-	PJ0	= portJ + 0
-	PJ1	= portJ + 1
-	PK0	= portK + 0
-	PK1	= portK + 1
-	PK2	= portK + 2
-	PK3	= portK + 3
-	PK4	= portH + 4
-	PK5	= portH + 5
-	PK6	= portH + 6
-	PK7	= portH + 7
-	PL0	= portL + 0
-	PL1	= portL + 1
-	PL2	= portL + 2
-	PL3	= portL + 3
-	PL4	= portL + 4
-	PL5	= portL + 5
-	PL6	= portL + 6
-	PL7	= portL + 7
-)
-```
-
-
-
-```go
-const (
-	PinInput	PinMode	= iota
-	PinInputPullup
-	PinOutput
-)
-```
-
-
-
-
-
-
-## Variables
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var I2C0 = I2C{}
-```
-
-I2C0 is the only I2C interface on most AVRs.
-
-
-```go
-var (
-	// UART0 is the hardware serial port on the AVR.
-	UART0 = UART{Buffer: NewRingBuffer()}
-)
-```
-
-UART
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-Return the current CPU frequency in hertz.
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the registers needed for ADC.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure()
-```
-
-Configure configures a ADCPin to be able to be used to read data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin, in the range 0..0xffff. The AVR
-has an ADC of 10 bits precision so the lower 6 bits will be zero.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-}
-```
-
-I2C on AVR.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency uint32
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure sets the pin to input or output.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*volatile.Register8, uint8)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-Warning: there are no separate pin set/clear registers on the AVR. The
-returned mask is only valid as long as no other pin in the same port has been
-changed.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*volatile.Register8, uint8)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-Warning: there are no separate pin set/clear registers on the AVR. The
-returned mask is only valid as long as no other pin in the same port has been
-changed.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(value bool)
-```
-
-Set changes the value of the GPIO pin. The pin must be configured as output.
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the AVR.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART on the AVR. Defaults to 9600 baud on Arduino.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/arduino-nano.md b/content/microcontrollers/machine/arduino-nano.md
deleted file mode 100644
index 312a1ec5..00000000
--- a/content/microcontrollers/machine/arduino-nano.md
+++ /dev/null
@@ -1,598 +0,0 @@
-
----
-title: arduino-nano
----
-
-
-## Constants
-
-```go
-const (
-	D0	= PD0	// RX0
-	D1	= PD1	// TX1
-	D2	= PD2
-	D3	= PD3
-	D4	= PD4
-	D5	= PD5
-	D6	= PD6
-	D7	= PD7
-	D8	= PB0
-	D9	= PB1
-	D10	= PB2
-	D11	= PB3
-	D12	= PB4
-	D13	= PB5
-)
-```
-
-Digital pins.
-
-
-```go
-const LED Pin = D13
-```
-
-LED on the Arduino
-
-
-```go
-const (
-	ADC0	Pin	= PC0
-	ADC1	Pin	= PC1
-	ADC2	Pin	= PC2
-	ADC3	Pin	= PC3
-	ADC4	Pin	= PC4	// Used by TWI for SDA
-	ADC5	Pin	= PC5	// Used by TWI for SCL
-)
-```
-
-ADC on the Arduino
-
-
-```go
-const (
-	UART_TX_PIN	Pin	= PD1
-	UART_RX_PIN	Pin	= PD0
-)
-```
-
-UART pins
-
-
-```go
-const (
-	PB0	= portB + 0
-	PB1	= portB + 1
-	PB2	= portB + 2
-	PB3	= portB + 3
-	PB4	= portB + 4
-	PB5	= portB + 5
-	PB6	= portB + 6
-	PB7	= portB + 7
-	PC0	= portC + 0
-	PC1	= portC + 1
-	PC2	= portC + 2
-	PC3	= portC + 3
-	PC4	= portC + 4
-	PC5	= portC + 5
-	PC6	= portC + 6
-	PC7	= portC + 7
-	PD0	= portD + 0
-	PD1	= portD + 1
-	PD2	= portD + 2
-	PD3	= portD + 3
-	PD4	= portD + 4
-	PD5	= portD + 5
-	PD6	= portD + 6
-	PD7	= portD + 7
-)
-```
-
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput	PinMode	= iota
-	PinInputPullup
-	PinOutput
-)
-```
-
-
-
-
-
-
-## Variables
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var I2C0 = I2C{}
-```
-
-I2C0 is the only I2C interface on most AVRs.
-
-
-```go
-var (
-	// UART0 is the hardware serial port on the AVR.
-	UART0 = UART{Buffer: NewRingBuffer()}
-)
-```
-
-UART
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-Return the current CPU frequency in hertz.
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the registers needed for ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the registers needed for PWM.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure()
-```
-
-Configure configures a ADCPin to be able to be used to read data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin, in the range 0..0xffff. The AVR
-has an ADC of 10 bits precision so the lower 6 bits will be zero.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-}
-```
-
-I2C on AVR.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency uint32
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure() error
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value. On the AVR this is normally a
-8-bit value ranging from 0 to 255.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure sets the pin to input or output.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*volatile.Register8, uint8)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-Warning: there are no separate pin set/clear registers on the AVR. The
-returned mask is only valid as long as no other pin in the same port has been
-changed.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*volatile.Register8, uint8)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-Warning: there are no separate pin set/clear registers on the AVR. The
-returned mask is only valid as long as no other pin in the same port has been
-changed.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(value bool)
-```
-
-Set changes the value of the GPIO pin. The pin must be configured as output.
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the AVR.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART on the AVR. Defaults to 9600 baud on Arduino.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/arduino-nano33.md b/content/microcontrollers/machine/arduino-nano33.md
deleted file mode 100644
index d2650851..00000000
--- a/content/microcontrollers/machine/arduino-nano33.md
+++ /dev/null
@@ -1,1663 +0,0 @@
-
----
-title: arduino-nano33
----
-
-
-## Constants
-
-```go
-const RESET_MAGIC_VALUE = 0x07738135
-```
-
-used to reset into bootloader
-
-
-```go
-const (
-	RX0	Pin	= PB23	// UART2 RX
-	TX1	Pin	= PB22	// UART2 TX
-
-	D2	Pin	= PB10	// PWM available
-	D3	Pin	= PB11	// PWM available
-	D4	Pin	= PA07
-	D5	Pin	= PA05	// PWM available
-	D6	Pin	= PA04	// PWM available
-	D7	Pin	= PA06
-
-	D8	Pin	= PA18
-	D9	Pin	= PA20	// PWM available
-	D10	Pin	= PA21	// PWM available
-	D11	Pin	= PA16	// PWM available
-	D12	Pin	= PA19	// PWM available
-
-	D13	Pin	= PA17
-)
-```
-
-GPIO Pins
-
-
-```go
-const (
-	A0	Pin	= PA02	// ADC/AIN[0]
-	A1	Pin	= PB02	// ADC/AIN[10]
-	A2	Pin	= PA11	// ADC/AIN[19]
-	A3	Pin	= PA10	// ADC/AIN[18],
-	A4	Pin	= PB08	// ADC/AIN[2], SCL:  SERCOM2/PAD[1]
-	A5	Pin	= PB09	// ADC/AIN[3], SDA:  SERCOM2/PAD[1]
-	A6	Pin	= PA09	// ADC/AIN[17]
-	A7	Pin	= PB03	// ADC/AIN[11]
-)
-```
-
-Analog pins
-
-
-```go
-const (
-	LED = D13
-)
-```
-
-
-
-```go
-const (
-	USBCDC_DM_PIN	Pin	= PA24
-	USBCDC_DP_PIN	Pin	= PA25
-)
-```
-
-UART0 aka USBCDC pins
-
-
-```go
-const (
-	UART_TX_PIN	Pin	= PA22
-	UART_RX_PIN	Pin	= PA23
-)
-```
-
-UART1 pins
-
-
-```go
-const (
-	SDA_PIN	Pin	= A4	// SDA: SERCOM4/PAD[1]
-	SCL_PIN	Pin	= A5	// SCL: SERCOM4/PAD[1]
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	Pin	= D13	// SCK: SERCOM1/PAD[1]
-	SPI0_SDO_PIN	Pin	= D11	// SDO: SERCOM1/PAD[0]
-	SPI0_SDI_PIN	Pin	= D12	// SDI: SERCOM1/PAD[3]
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	NINA_SDO	Pin	= PA12
-	NINA_SDI	Pin	= PA13
-	NINA_CS		Pin	= PA14
-	NINA_SCK	Pin	= PA15
-	NINA_GPIO0	Pin	= PA27
-	NINA_RESETN	Pin	= PA08
-	NINA_ACK	Pin	= PA28
-	NINA_TX		Pin	= PA22
-	NINA_RX		Pin	= PA23
-)
-```
-
-NINA-W102 Pins
-
-
-```go
-const (
-	I2S_SCK_PIN	Pin	= PA10
-	I2S_SD_PIN	Pin	= PA08
-	I2S_WS_PIN		= NoPin	// TODO: figure out what this is on Arduino Nano 33.
-)
-```
-
-I2S pins
-
-
-```go
-const (
-	PA00	Pin	= 0
-	PA01	Pin	= 1
-	PA02	Pin	= 2
-	PA03	Pin	= 3
-	PA04	Pin	= 4
-	PA05	Pin	= 5
-	PA06	Pin	= 6
-	PA07	Pin	= 7
-	PA08	Pin	= 8
-	PA09	Pin	= 9
-	PA10	Pin	= 10
-	PA11	Pin	= 11
-	PA12	Pin	= 12
-	PA13	Pin	= 13
-	PA14	Pin	= 14
-	PA15	Pin	= 15
-	PA16	Pin	= 16
-	PA17	Pin	= 17
-	PA18	Pin	= 18
-	PA19	Pin	= 19
-	PA20	Pin	= 20
-	PA21	Pin	= 21
-	PA22	Pin	= 22
-	PA23	Pin	= 23
-	PA24	Pin	= 24
-	PA25	Pin	= 25
-	PA26	Pin	= 26
-	PA27	Pin	= 27
-	PA28	Pin	= 28
-	PA29	Pin	= 29
-	PA30	Pin	= 30
-	PA31	Pin	= 31
-	PB00	Pin	= 32
-	PB01	Pin	= 33
-	PB02	Pin	= 34
-	PB03	Pin	= 35
-	PB04	Pin	= 36
-	PB05	Pin	= 37
-	PB06	Pin	= 38
-	PB07	Pin	= 39
-	PB08	Pin	= 40
-	PB09	Pin	= 41
-	PB10	Pin	= 42
-	PB11	Pin	= 43
-	PB12	Pin	= 44
-	PB13	Pin	= 45
-	PB14	Pin	= 46
-	PB15	Pin	= 47
-	PB16	Pin	= 48
-	PB17	Pin	= 49
-	PB18	Pin	= 50
-	PB19	Pin	= 51
-	PB20	Pin	= 52
-	PB21	Pin	= 53
-	PB22	Pin	= 54
-	PB23	Pin	= 55
-	PB24	Pin	= 56
-	PB25	Pin	= 57
-	PB26	Pin	= 58
-	PB27	Pin	= 59
-	PB28	Pin	= 60
-	PB29	Pin	= 61
-	PB30	Pin	= 62
-	PB31	Pin	= 63
-)
-```
-
-Hardware pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const (
-	I2SModeSource	I2SMode	= iota
-	I2SModeReceiver
-	I2SModePDM
-)
-```
-
-
-
-```go
-const (
-	I2StandardPhilips	I2SStandard	= iota
-	I2SStandardMSB
-	I2SStandardLSB
-)
-```
-
-
-
-```go
-const (
-	I2SClockSourceInternal	I2SClockSource	= iota
-	I2SClockSourceExternal
-)
-```
-
-
-
-```go
-const (
-	I2SDataFormatDefault	I2SDataFormat	= 0
-	I2SDataFormat8bit			= 8
-	I2SDataFormat16bit			= 16
-	I2SDataFormat24bit			= 24
-	I2SDataFormat32bit			= 32
-)
-```
-
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinAnalog	PinMode	= 1
-	PinSERCOM	PinMode	= 2
-	PinSERCOMAlt	PinMode	= 3
-	PinTimer	PinMode	= 4
-	PinTimerAlt	PinMode	= 5
-	PinCom		PinMode	= 6
-	//PinAC_CLK        PinMode = 7
-	PinDigital		PinMode	= 8
-	PinInput		PinMode	= 9
-	PinInputPullup		PinMode	= 10
-	PinOutput		PinMode	= 11
-	PinPWM			PinMode	= PinTimer
-	PinPWMAlt		PinMode	= PinTimerAlt
-	PinInputPulldown	PinMode	= 12
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
-	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
-	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	Mode0	= 0
-	Mode1	= 1
-	Mode2	= 2
-	Mode3	= 3
-)
-```
-
-SPI phase and polarity configs CPOL and CPHA
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART1 = UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	sam.SERCOM3_USART,
-		SERCOM:	3,
-	}
-)
-```
-
-UART1 on the Arduino Nano 33 connects to the onboard NINA-W102 WiFi chip.
-
-
-```go
-var (
-	UART2 = UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	sam.SERCOM5_USART,
-		SERCOM:	5,
-	}
-)
-```
-
-UART2 on the Arduino Nano 33 connects to the normal TX/RX pins.
-
-
-```go
-var (
-	I2C0 = I2C{
-		Bus:	sam.SERCOM4_I2CM,
-		SERCOM:	4,
-	}
-)
-```
-
-I2C on the Arduino Nano 33.
-
-
-```go
-var (
-	SPI0 = SPI{
-		Bus:	sam.SERCOM1_SPI,
-		SERCOM:	1,
-	}
-)
-```
-
-SPI on the Arduino Nano 33.
-
-
-```go
-var (
-	SPI1	= SPI{
-		Bus:	sam.SERCOM2_SPI,
-		SERCOM:	2,
-	}
-	NINA_SPI	= SPI1
-)
-```
-
-SPI1 is connected to the NINA-W102 chip on the Arduino Nano 33.
-
-
-```go
-var (
-	I2S0 = I2S{Bus: sam.I2S}
-)
-```
-
-I2S on the Arduino Nano 33.
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	// UART0 is actually a USB CDC interface.
-	UART0 = USBCDC{Buffer: NewRingBuffer()}
-)
-```
-
-
-
-```go
-var (
-	DAC0 = DAC{}
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-Return the current CPU frequency in hertz.
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the PWM interface.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-### func ResetProcessor
-
-```go
-func ResetProcessor()
-```
-
-ResetProcessor should perform a system reset in preperation
-to switch to the bootloader to flash new firmware.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure()
-```
-
-Configure configures a ADCPin to be able to be used to read data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin, in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DAC
-
-```go
-type DAC struct {
-}
-```
-
-DAC on the SAMD21.
-
-
-
-### func (DAC) Configure
-
-```go
-func (dac DAC) Configure(config DACConfig)
-```
-
-Configure the DAC.
-output pin must already be configured.
-
-
-### func (DAC) Set
-
-```go
-func (dac DAC) Set(value uint16) error
-```
-
-Set writes a single 16-bit value to the DAC.
-Since the ATSAMD21 only has a 10-bit DAC, the passed-in value will be scaled down.
-
-
-
-
-## type DACConfig
-
-```go
-type DACConfig struct {
-}
-```
-
-DACConfig placeholder for future expansion.
-
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus	*sam.SERCOM_I2CM_Type
-	SERCOM	uint8
-}
-```
-
-I2C on the SAMD21.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig) error
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) SetBaudRate
-
-```go
-func (i2c I2C) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the I2C.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteByte
-
-```go
-func (i2c I2C) WriteByte(data byte) error
-```
-
-WriteByte writes a single byte to the I2C bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type I2S
-
-```go
-type I2S struct {
-	Bus *sam.I2S_Type
-}
-```
-
-I2S
-
-
-
-### func (I2S) Close
-
-```go
-func (i2s I2S) Close() error
-```
-
-Close the I2S bus.
-
-
-### func (I2S) Configure
-
-```go
-func (i2s I2S) Configure(config I2SConfig)
-```
-
-Configure is used to configure the I2S interface. You must call this
-before you can use the I2S bus.
-
-
-### func (I2S) Read
-
-```go
-func (i2s I2S) Read(p []uint32) (n int, err error)
-```
-
-Read data from the I2S bus into the provided slice.
-The I2S bus must already have been configured correctly.
-
-
-### func (I2S) Write
-
-```go
-func (i2s I2S) Write(p []uint32) (n int, err error)
-```
-
-Write data to the I2S bus from the provided slice.
-The I2S bus must already have been configured correctly.
-
-
-
-
-## type I2SClockSource
-
-```go
-type I2SClockSource uint8
-```
-
-
-
-
-
-
-## type I2SConfig
-
-```go
-type I2SConfig struct {
-	SCK		Pin
-	WS		Pin
-	SD		Pin
-	Mode		I2SMode
-	Standard	I2SStandard
-	ClockSource	I2SClockSource
-	DataFormat	I2SDataFormat
-	AudioFrequency	uint32
-	MainClockOutput	bool
-	Stereo		bool
-}
-```
-
-All fields are optional and may not be required or used on a particular platform.
-
-
-
-
-
-## type I2SDataFormat
-
-```go
-type I2SDataFormat uint8
-```
-
-
-
-
-
-
-## type I2SMode
-
-```go
-type I2SMode uint8
-```
-
-
-
-
-
-
-## type I2SStandard
-
-```go
-type I2SStandard uint8
-```
-
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure() error
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus	*sam.SERCOM_SPI_Type
-	SERCOM	uint8
-}
-```
-
-SPI
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig) error
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer		*RingBuffer
-	Bus		*sam.SERCOM_USART_Type
-	SERCOM		uint8
-	Interrupt	interrupt.Interrupt
-}
-```
-
-UART on the SAMD21.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig) error
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer *RingBuffer
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the SAMD21.
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (USBCDC) Configure
-
-```go
-func (usbcdc USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/arduino-zero.md b/content/microcontrollers/machine/arduino-zero.md
deleted file mode 100644
index 36e685e6..00000000
--- a/content/microcontrollers/machine/arduino-zero.md
+++ /dev/null
@@ -1,1603 +0,0 @@
-
----
-title: arduino-zero
----
-
-
-## Constants
-
-```go
-const RESET_MAGIC_VALUE = 0x07738135
-```
-
-used to reset into bootloader
-
-
-```go
-const (
-	D0	= PA11	// RX
-	D1	= PA10	// TX
-	D2	= PA14
-	D3	= PA09	// PWM available
-	D4	= PA08	// PWM available
-	D5	= PA15	// PWM available
-	D6	= PA20	// PWM available
-	D7	= PA21
-)
-```
-
-GPIO Pins - Digital Low
-
-
-```go
-const (
-	D8	= PA06	// PWM available
-	D9	= PA07	// PWM available
-	D10	= PA18	// PWM available
-	D11	= PA16	// PWM available
-	D12	= PA19	// PWM available
-	D13	= PA17	// PWM available
-)
-```
-
-GPIO Pins - Digital High
-
-
-```go
-const (
-	LED		= LED1
-	LED1	Pin	= D13
-	LED2	Pin	= PA27	// TX LED
-	LED3	Pin	= PB03	// RX LED
-)
-```
-
-LEDs on the Arduino Zero
-
-
-```go
-const (
-	AREF	Pin	= PA03
-	ADC0	Pin	= PA02
-	ADC1	Pin	= PB08
-	ADC2	Pin	= PB09
-	ADC3	Pin	= PA04
-	ADC4	Pin	= PA05
-	ADC5	Pin	= PB02
-)
-```
-
-ADC pins
-
-
-```go
-const (
-	SPI0_SDO_PIN	Pin	= PA16	// MOSI: SERCOM1/PAD[0]
-	SPI0_SDI_PIN	Pin	= PA19	// MISO: SERCOM1/PAD[2]
-	SPI0_SCK_PIN	Pin	= PA17	// SCK:  SERCOM1/PAD[3]
-)
-```
-
-SPI pins - EDBG connected
-
-
-```go
-const (
-	SPI1_SDO_PIN	Pin	= PB10	// MOSI: SERCOM4/PAD[2] - Pin 4
-	SPI1_SDI_PIN	Pin	= PA12	// MISO: SERCOM4/PAD[0] - Pin 1
-	SPI1_SCK_PIN	Pin	= PB11	// SCK:  SERCOM4/PAD[3] - Pin 3
-)
-```
-
-SPI pins (Legacy ICSP)
-
-
-```go
-const (
-	SDA_PIN	Pin	= PA22	// SDA: SERCOM3/PAD[0] - Pin 20
-	SCL_PIN	Pin	= PA23	// SCL: SERCOM3/PAD[1] - Pin 21
-)
-```
-
-I2C pins - EDBG connected
-
-
-```go
-const (
-	I2S_SCK_PIN	Pin	= PA10
-	I2S_SD_PIN	Pin	= PA07
-	I2S_WS_PIN	Pin	= PA11
-)
-```
-
-I2S pins - might not be exposed
-
-
-```go
-const (
-	UART_RX_PIN	Pin	= D0
-	UART_TX_PIN	Pin	= D1
-)
-```
-
-UART0 pins - EDBG connected
-
-
-```go
-const (
-	USBCDC_DM_PIN	Pin	= PA24
-	USBCDC_DP_PIN	Pin	= PA25
-)
-```
-
-'native' USB port pins
-
-
-```go
-const (
-	XIN32	Pin	= PA00
-	XOUT32	Pin	= PA01
-)
-```
-
-32.768 KHz Crystal
-
-
-```go
-const (
-	PA00	Pin	= 0
-	PA01	Pin	= 1
-	PA02	Pin	= 2
-	PA03	Pin	= 3
-	PA04	Pin	= 4
-	PA05	Pin	= 5
-	PA06	Pin	= 6
-	PA07	Pin	= 7
-	PA08	Pin	= 8
-	PA09	Pin	= 9
-	PA10	Pin	= 10
-	PA11	Pin	= 11
-	PA12	Pin	= 12
-	PA13	Pin	= 13
-	PA14	Pin	= 14
-	PA15	Pin	= 15
-	PA16	Pin	= 16
-	PA17	Pin	= 17
-	PA18	Pin	= 18
-	PA19	Pin	= 19
-	PA20	Pin	= 20
-	PA21	Pin	= 21
-	PA22	Pin	= 22
-	PA23	Pin	= 23
-	PA24	Pin	= 24
-	PA25	Pin	= 25
-	PA26	Pin	= 26
-	PA27	Pin	= 27
-	PA28	Pin	= 28
-	PA29	Pin	= 29
-	PA30	Pin	= 30
-	PA31	Pin	= 31
-	PB00	Pin	= 32
-	PB01	Pin	= 33
-	PB02	Pin	= 34
-	PB03	Pin	= 35
-	PB04	Pin	= 36
-	PB05	Pin	= 37
-	PB06	Pin	= 38
-	PB07	Pin	= 39
-	PB08	Pin	= 40
-	PB09	Pin	= 41
-	PB10	Pin	= 42
-	PB11	Pin	= 43
-	PB12	Pin	= 44
-	PB13	Pin	= 45
-	PB14	Pin	= 46
-	PB15	Pin	= 47
-	PB16	Pin	= 48
-	PB17	Pin	= 49
-	PB18	Pin	= 50
-	PB19	Pin	= 51
-	PB20	Pin	= 52
-	PB21	Pin	= 53
-	PB22	Pin	= 54
-	PB23	Pin	= 55
-	PB24	Pin	= 56
-	PB25	Pin	= 57
-	PB26	Pin	= 58
-	PB27	Pin	= 59
-	PB28	Pin	= 60
-	PB29	Pin	= 61
-	PB30	Pin	= 62
-	PB31	Pin	= 63
-)
-```
-
-Hardware pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const (
-	I2SModeSource	I2SMode	= iota
-	I2SModeReceiver
-	I2SModePDM
-)
-```
-
-
-
-```go
-const (
-	I2StandardPhilips	I2SStandard	= iota
-	I2SStandardMSB
-	I2SStandardLSB
-)
-```
-
-
-
-```go
-const (
-	I2SClockSourceInternal	I2SClockSource	= iota
-	I2SClockSourceExternal
-)
-```
-
-
-
-```go
-const (
-	I2SDataFormatDefault	I2SDataFormat	= 0
-	I2SDataFormat8bit			= 8
-	I2SDataFormat16bit			= 16
-	I2SDataFormat24bit			= 24
-	I2SDataFormat32bit			= 32
-)
-```
-
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinAnalog	PinMode	= 1
-	PinSERCOM	PinMode	= 2
-	PinSERCOMAlt	PinMode	= 3
-	PinTimer	PinMode	= 4
-	PinTimerAlt	PinMode	= 5
-	PinCom		PinMode	= 6
-	//PinAC_CLK        PinMode = 7
-	PinDigital		PinMode	= 8
-	PinInput		PinMode	= 9
-	PinInputPullup		PinMode	= 10
-	PinOutput		PinMode	= 11
-	PinPWM			PinMode	= PinTimer
-	PinPWMAlt		PinMode	= PinTimerAlt
-	PinInputPulldown	PinMode	= 12
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
-	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
-	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	Mode0	= 0
-	Mode1	= 1
-	Mode2	= 2
-	Mode3	= 3
-)
-```
-
-SPI phase and polarity configs CPOL and CPHA
-
-
-
-
-
-## Variables
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	// UART0 is actually a USB CDC interface.
-	UART0 = USBCDC{Buffer: NewRingBuffer()}
-)
-```
-
-
-
-```go
-var (
-	DAC0 = DAC{}
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-Return the current CPU frequency in hertz.
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the PWM interface.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-### func ResetProcessor
-
-```go
-func ResetProcessor()
-```
-
-ResetProcessor should perform a system reset in preperation
-to switch to the bootloader to flash new firmware.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure()
-```
-
-Configure configures a ADCPin to be able to be used to read data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin, in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DAC
-
-```go
-type DAC struct {
-}
-```
-
-DAC on the SAMD21.
-
-
-
-### func (DAC) Configure
-
-```go
-func (dac DAC) Configure(config DACConfig)
-```
-
-Configure the DAC.
-output pin must already be configured.
-
-
-### func (DAC) Set
-
-```go
-func (dac DAC) Set(value uint16) error
-```
-
-Set writes a single 16-bit value to the DAC.
-Since the ATSAMD21 only has a 10-bit DAC, the passed-in value will be scaled down.
-
-
-
-
-## type DACConfig
-
-```go
-type DACConfig struct {
-}
-```
-
-DACConfig placeholder for future expansion.
-
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus	*sam.SERCOM_I2CM_Type
-	SERCOM	uint8
-}
-```
-
-I2C on the SAMD21.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig) error
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) SetBaudRate
-
-```go
-func (i2c I2C) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the I2C.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteByte
-
-```go
-func (i2c I2C) WriteByte(data byte) error
-```
-
-WriteByte writes a single byte to the I2C bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type I2S
-
-```go
-type I2S struct {
-	Bus *sam.I2S_Type
-}
-```
-
-I2S
-
-
-
-### func (I2S) Close
-
-```go
-func (i2s I2S) Close() error
-```
-
-Close the I2S bus.
-
-
-### func (I2S) Configure
-
-```go
-func (i2s I2S) Configure(config I2SConfig)
-```
-
-Configure is used to configure the I2S interface. You must call this
-before you can use the I2S bus.
-
-
-### func (I2S) Read
-
-```go
-func (i2s I2S) Read(p []uint32) (n int, err error)
-```
-
-Read data from the I2S bus into the provided slice.
-The I2S bus must already have been configured correctly.
-
-
-### func (I2S) Write
-
-```go
-func (i2s I2S) Write(p []uint32) (n int, err error)
-```
-
-Write data to the I2S bus from the provided slice.
-The I2S bus must already have been configured correctly.
-
-
-
-
-## type I2SClockSource
-
-```go
-type I2SClockSource uint8
-```
-
-
-
-
-
-
-## type I2SConfig
-
-```go
-type I2SConfig struct {
-	SCK		Pin
-	WS		Pin
-	SD		Pin
-	Mode		I2SMode
-	Standard	I2SStandard
-	ClockSource	I2SClockSource
-	DataFormat	I2SDataFormat
-	AudioFrequency	uint32
-	MainClockOutput	bool
-	Stereo		bool
-}
-```
-
-All fields are optional and may not be required or used on a particular platform.
-
-
-
-
-
-## type I2SDataFormat
-
-```go
-type I2SDataFormat uint8
-```
-
-
-
-
-
-
-## type I2SMode
-
-```go
-type I2SMode uint8
-```
-
-
-
-
-
-
-## type I2SStandard
-
-```go
-type I2SStandard uint8
-```
-
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure() error
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus	*sam.SERCOM_SPI_Type
-	SERCOM	uint8
-}
-```
-
-SPI
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig) error
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer		*RingBuffer
-	Bus		*sam.SERCOM_USART_Type
-	SERCOM		uint8
-	Interrupt	interrupt.Interrupt
-}
-```
-
-UART on the SAMD21.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig) error
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer *RingBuffer
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the SAMD21.
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (USBCDC) Configure
-
-```go
-func (usbcdc USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/arduino.md b/content/microcontrollers/machine/arduino.md
deleted file mode 100644
index edf8d3cd..00000000
--- a/content/microcontrollers/machine/arduino.md
+++ /dev/null
@@ -1,598 +0,0 @@
-
----
-title: arduino
----
-
-
-## Constants
-
-```go
-const (
-	D0	= PD0	// RX
-	D1	= PD1	// TX
-	D2	= PD2
-	D3	= PD3
-	D4	= PD4
-	D5	= PD5
-	D6	= PD6
-	D7	= PD7
-	D8	= PB0
-	D9	= PB1
-	D10	= PB2
-	D11	= PB3
-	D12	= PB4
-	D13	= PB5
-)
-```
-
-Digital pins, marked as plain numbers on the board.
-
-
-```go
-const LED Pin = D13
-```
-
-LED on the Arduino
-
-
-```go
-const (
-	ADC0	Pin	= PC0
-	ADC1	Pin	= PC1
-	ADC2	Pin	= PC2
-	ADC3	Pin	= PC3
-	ADC4	Pin	= PC4	// Used by TWI for SDA
-	ADC5	Pin	= PC5	// Used by TWI for SCL
-)
-```
-
-ADC on the Arduino
-
-
-```go
-const (
-	UART_TX_PIN	Pin	= PD1
-	UART_RX_PIN	Pin	= PD0
-)
-```
-
-UART pins
-
-
-```go
-const (
-	PB0	= portB + 0
-	PB1	= portB + 1
-	PB2	= portB + 2
-	PB3	= portB + 3
-	PB4	= portB + 4
-	PB5	= portB + 5
-	PB6	= portB + 6
-	PB7	= portB + 7
-	PC0	= portC + 0
-	PC1	= portC + 1
-	PC2	= portC + 2
-	PC3	= portC + 3
-	PC4	= portC + 4
-	PC5	= portC + 5
-	PC6	= portC + 6
-	PC7	= portC + 7
-	PD0	= portD + 0
-	PD1	= portD + 1
-	PD2	= portD + 2
-	PD3	= portD + 3
-	PD4	= portD + 4
-	PD5	= portD + 5
-	PD6	= portD + 6
-	PD7	= portD + 7
-)
-```
-
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput	PinMode	= iota
-	PinInputPullup
-	PinOutput
-)
-```
-
-
-
-
-
-
-## Variables
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var I2C0 = I2C{}
-```
-
-I2C0 is the only I2C interface on most AVRs.
-
-
-```go
-var (
-	// UART0 is the hardware serial port on the AVR.
-	UART0 = UART{Buffer: NewRingBuffer()}
-)
-```
-
-UART
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-Return the current CPU frequency in hertz.
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the registers needed for ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the registers needed for PWM.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure()
-```
-
-Configure configures a ADCPin to be able to be used to read data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin, in the range 0..0xffff. The AVR
-has an ADC of 10 bits precision so the lower 6 bits will be zero.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-}
-```
-
-I2C on AVR.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency uint32
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure() error
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value. On the AVR this is normally a
-8-bit value ranging from 0 to 255.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure sets the pin to input or output.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*volatile.Register8, uint8)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-Warning: there are no separate pin set/clear registers on the AVR. The
-returned mask is only valid as long as no other pin in the same port has been
-changed.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*volatile.Register8, uint8)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-Warning: there are no separate pin set/clear registers on the AVR. The
-returned mask is only valid as long as no other pin in the same port has been
-changed.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(value bool)
-```
-
-Set changes the value of the GPIO pin. The pin must be configured as output.
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the AVR.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART on the AVR. Defaults to 9600 baud on Arduino.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/atmega1284p.md b/content/microcontrollers/machine/atmega1284p.md
deleted file mode 100644
index 72c2410a..00000000
--- a/content/microcontrollers/machine/atmega1284p.md
+++ /dev/null
@@ -1,525 +0,0 @@
-
----
-title: atmega1284p
----
-
-
-## Constants
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PA0	= portA + 0
-	PA1	= portA + 1
-	PA2	= portA + 2
-	PA3	= portA + 3
-	PA4	= portA + 4
-	PA5	= portA + 5
-	PA6	= portA + 6
-	PA7	= portA + 7
-	PB0	= portB + 0
-	PB1	= portB + 1
-	PB2	= portB + 2
-	PB3	= portB + 3
-	PB4	= portB + 4
-	PB5	= portB + 5
-	PB6	= portB + 6
-	PB7	= portB + 7
-	PC0	= portC + 0
-	PC1	= portC + 1
-	PC2	= portC + 2
-	PC3	= portC + 3
-	PC4	= portC + 4
-	PC5	= portC + 5
-	PC6	= portC + 6
-	PC7	= portC + 7
-	PD0	= portD + 0
-	PD1	= portD + 1
-	PD2	= portD + 2
-	PD3	= portD + 3
-	PD4	= portD + 4
-	PD5	= portD + 5
-	PD6	= portD + 6
-	PD7	= portD + 7
-)
-```
-
-
-
-```go
-const (
-	PinInput	PinMode	= iota
-	PinInputPullup
-	PinOutput
-)
-```
-
-
-
-
-
-
-## Variables
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var I2C0 = I2C{}
-```
-
-I2C0 is the only I2C interface on most AVRs.
-
-
-```go
-var (
-	// UART0 is the hardware serial port on the AVR.
-	UART0 = UART{Buffer: NewRingBuffer()}
-)
-```
-
-UART
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-Return the current CPU frequency in hertz.
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the registers needed for ADC.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure()
-```
-
-Configure configures a ADCPin to be able to be used to read data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin, in the range 0..0xffff. The AVR
-has an ADC of 10 bits precision so the lower 6 bits will be zero.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-}
-```
-
-I2C on AVR.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency uint32
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure sets the pin to input or output.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*volatile.Register8, uint8)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-Warning: there are no separate pin set/clear registers on the AVR. The
-returned mask is only valid as long as no other pin in the same port has been
-changed.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*volatile.Register8, uint8)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-Warning: there are no separate pin set/clear registers on the AVR. The
-returned mask is only valid as long as no other pin in the same port has been
-changed.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(value bool)
-```
-
-Set changes the value of the GPIO pin. The pin must be configured as output.
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the AVR.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART on the AVR. Defaults to 9600 baud on Arduino.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/bluepill.md b/content/microcontrollers/machine/bluepill.md
deleted file mode 100644
index f254f3d5..00000000
--- a/content/microcontrollers/machine/bluepill.md
+++ /dev/null
@@ -1,669 +0,0 @@
-
----
-title: bluepill
----
-
-
-## Constants
-
-```go
-const (
-	PA0	= portA + 0
-	PA1	= portA + 1
-	PA2	= portA + 2
-	PA3	= portA + 3
-	PA4	= portA + 4
-	PA5	= portA + 5
-	PA6	= portA + 6
-	PA7	= portA + 7
-	PA8	= portA + 8
-	PA9	= portA + 9
-	PA10	= portA + 10
-	PA11	= portA + 11
-	PA12	= portA + 12
-	PA13	= portA + 13
-	PA14	= portA + 14
-	PA15	= portA + 15
-	PB0	= portB + 0
-	PB1	= portB + 1
-	PB2	= portB + 2
-	PB3	= portB + 3
-	PB4	= portB + 4
-	PB5	= portB + 5
-	PB6	= portB + 6
-	PB7	= portB + 7
-	PB8	= portB + 8
-	PB9	= portB + 9
-	PB10	= portB + 10
-	PB11	= portB + 11
-	PB12	= portB + 12
-	PB13	= portB + 13
-	PB14	= portB + 14
-	PB15	= portB + 15
-	PC13	= portC + 13
-	PC14	= portC + 14
-	PC15	= portC + 15
-)
-```
-
-https://wiki.stm32duino.com/index.php?title=File:Bluepillpinout.gif
-
-
-```go
-const (
-	LED = PC13
-)
-```
-
-
-
-```go
-const (
-	UART_TX_PIN	= PA9
-	UART_RX_PIN	= PA10
-	UART_ALT_TX_PIN	= PB6
-	UART_ALT_RX_PIN	= PB7
-)
-```
-
-UART pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	= PA5
-	SPI0_SDO_PIN	= PA7
-	SPI0_SDI_PIN	= PA6
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	SDA_PIN	= PB7
-	SCL_PIN	= PB6
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput	PinMode	= 0	// Input mode
-	PinOutput10MHz	PinMode	= 1	// Output mode, max speed 10MHz
-	PinOutput2MHz	PinMode	= 2	// Output mode, max speed 2MHz
-	PinOutput50MHz	PinMode	= 3	// Output mode, max speed 50MHz
-	PinOutput	PinMode	= PinOutput2MHz
-
-	PinInputModeAnalog	PinMode	= 0	// Input analog mode
-	PinInputModeFloating	PinMode	= 4	// Input floating mode
-	PinInputModePullUpDown	PinMode	= 8	// Input pull up/down mode
-	PinInputModeReserved	PinMode	= 12	// Input mode (reserved)
-
-	PinOutputModeGPPushPull		PinMode	= 0	// Output mode general purpose push/pull
-	PinOutputModeGPOpenDrain	PinMode	= 4	// Output mode general purpose open drain
-	PinOutputModeAltPushPull	PinMode	= 8	// Output mode alt. purpose push/pull
-	PinOutputModeAltOpenDrain	PinMode	= 12	// Output mode alt. purpose open drain
-)
-```
-
-
-
-```go
-const (
-	Mode0	= 0
-	Mode1	= 1
-	Mode2	= 2
-	Mode3	= 3
-)
-```
-
-SPI phase and polarity configs CPOL and CPHA
-
-
-
-
-
-## Variables
-
-```go
-var (
-	// USART1 is the first hardware serial port on the STM32.
-	// Both UART0 and UART1 refer to USART1.
-	UART0	= UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	stm32.USART1,
-	}
-	UART1	= UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	stm32.USART2,
-	}
-)
-```
-
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	SPI1	= SPI{Bus: stm32.SPI1}
-	SPI0	= SPI1
-)
-```
-
-There are 3 SPI interfaces on the STM32F103xx.
-Since the first interface is named SPI1, both SPI0 and SPI1 refer to SPI1.
-TODO: implement SPI2 and SPI3.
-
-
-```go
-var (
-	I2C1	= I2C{Bus: stm32.I2C1}
-	I2C0	= I2C1
-)
-```
-
-There are 2 I2C interfaces on the STM32F103xx.
-Since the first interface is named I2C1, both I2C0 and I2C1 refer to I2C1.
-TODO: implement I2C2.
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus *stm32.I2C_Type
-}
-```
-
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteByte
-
-```go
-func (i2c I2C) WriteByte(data byte) error
-```
-
-WriteByte writes a single byte to the I2C bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given I/O settings.
-stm32f1xx uses different technique for setting the GPIO pins than the stm32f407
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *stm32.SPI_Type
-}
-```
-
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the STM32 SPI1 interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer		*RingBuffer
-	Bus		*stm32.USART_Type
-	Interrupt	interrupt.Interrupt
-}
-```
-
-UART representation
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART. Defer to chip-specific
-routines for calculation
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/circuitplay-bluefruit.md b/content/microcontrollers/machine/circuitplay-bluefruit.md
deleted file mode 100644
index da6dc975..00000000
--- a/content/microcontrollers/machine/circuitplay-bluefruit.md
+++ /dev/null
@@ -1,1380 +0,0 @@
-
----
-title: circuitplay-bluefruit
----
-
-
-## Constants
-
-```go
-const HasLowFrequencyCrystal = false
-```
-
-
-
-```go
-const (
-	D0	= P0_30
-	D1	= P0_14
-	D2	= P0_05
-	D3	= P0_04
-	D4	= P1_02
-	D5	= P1_15
-	D6	= P0_02
-	D7	= P1_06
-	D8	= P0_13
-	D9	= P0_29
-	D10	= P0_03
-	D11	= P1_04
-	D12	= P0_26
-	D13	= P1_14
-)
-```
-
-GPIO Pins
-
-
-```go
-const (
-	A1	= P0_02
-	A2	= P0_29
-	A3	= P0_03
-	A4	= P0_04
-	A5	= P0_05
-	A6	= P0_30
-	A7	= P0_14
-	A8	= P0_28
-	A9	= P0_31
-)
-```
-
-Analog Pins
-
-
-```go
-const (
-	LED		= D13
-	NEOPIXELS	= D8
-
-	BUTTONA	= D4
-	BUTTONB	= D5
-	SLIDER	= D7	// built-in slide switch
-
-	BUTTON	= BUTTONA
-	BUTTON1	= BUTTONB
-
-	LIGHTSENSOR	= A8
-	TEMPSENSOR	= A9
-)
-```
-
-
-
-```go
-const (
-	UART_TX_PIN	= P0_14	// PORTB
-	UART_RX_PIN	= P0_30	// PORTB
-)
-```
-
-UART0 pins (logical UART1)
-
-
-```go
-const (
-	SDA_PIN	= P0_05	// I2C0 external
-	SCL_PIN	= P0_04	// I2C0 external
-
-	SDA1_PIN	= P0_00	// I2C1 internal
-	SCL1_PIN	= P0_01	// I2C1 internal
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	= P0_19	// SCK
-	SPI0_SDO_PIN	= P0_21	// SDO
-	SPI0_SDI_PIN	= P0_23	// SDI
-)
-```
-
-SPI pins (internal flash)
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Disconnect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
-	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
-	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	P0_00	Pin	= 0
-	P0_01	Pin	= 1
-	P0_02	Pin	= 2
-	P0_03	Pin	= 3
-	P0_04	Pin	= 4
-	P0_05	Pin	= 5
-	P0_06	Pin	= 6
-	P0_07	Pin	= 7
-	P0_08	Pin	= 8
-	P0_09	Pin	= 9
-	P0_10	Pin	= 10
-	P0_11	Pin	= 11
-	P0_12	Pin	= 12
-	P0_13	Pin	= 13
-	P0_14	Pin	= 14
-	P0_15	Pin	= 15
-	P0_16	Pin	= 16
-	P0_17	Pin	= 17
-	P0_18	Pin	= 18
-	P0_19	Pin	= 19
-	P0_20	Pin	= 20
-	P0_21	Pin	= 21
-	P0_22	Pin	= 22
-	P0_23	Pin	= 23
-	P0_24	Pin	= 24
-	P0_25	Pin	= 25
-	P0_26	Pin	= 26
-	P0_27	Pin	= 27
-	P0_28	Pin	= 28
-	P0_29	Pin	= 29
-	P0_30	Pin	= 30
-	P0_31	Pin	= 31
-	P1_00	Pin	= 32
-	P1_01	Pin	= 33
-	P1_02	Pin	= 34
-	P1_03	Pin	= 35
-	P1_04	Pin	= 36
-	P1_05	Pin	= 37
-	P1_06	Pin	= 38
-	P1_07	Pin	= 39
-	P1_08	Pin	= 40
-	P1_09	Pin	= 41
-	P1_10	Pin	= 42
-	P1_11	Pin	= 43
-	P1_12	Pin	= 44
-	P1_13	Pin	= 45
-	P1_14	Pin	= 46
-	P1_15	Pin	= 47
-)
-```
-
-Hardware pins
-
-
-```go
-const (
-	DFU_MAGIC_SERIAL_ONLY_RESET	= 0x4e
-	DFU_MAGIC_UF2_RESET		= 0x57
-	DFU_MAGIC_OTA_RESET		= 0xA8
-)
-```
-
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART0 = USB
-)
-```
-
-UART0 is the USB device
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-```go
-var (
-	// NRF_UART0 is the hardware UART on the NRF SoC.
-	NRF_UART0 = UART{Buffer: NewRingBuffer()}
-)
-```
-
-UART
-
-
-```go
-var (
-	I2C0	= I2C{Bus: nrf.TWI0}
-	I2C1	= I2C{Bus: nrf.TWI1}
-)
-```
-
-There are 2 I2C interfaces on the NRF.
-
-
-```go
-var (
-	SPI0	= SPI{Bus: nrf.SPI0}
-	SPI1	= SPI{Bus: nrf.SPI1}
-)
-```
-
-There are 2 SPI interfaces on the NRF5x.
-
-
-```go
-var (
-	USB	= USBCDC{Buffer: NewRingBuffer()}
-
-	usbEndpointDescriptors	[8]usbDeviceDescriptor
-
-	udd_ep_in_cache_buffer	[7][128]uint8
-	udd_ep_out_cache_buffer	[7][128]uint8
-
-	sendOnEP0DATADONE	struct {
-		ptr	*byte
-		count	int
-	}
-	isEndpointHalt		= false
-	isRemoteWakeUpEnabled	= false
-	endPoints		= []uint32{usb_ENDPOINT_TYPE_CONTROL,
-		(usb_ENDPOINT_TYPE_INTERRUPT | usbEndpointIn),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointOut),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointIn)}
-
-	usbConfiguration		uint8
-	usbSetInterface			uint8
-	usbLineInfo			= cdcLineInfo{115200, 0x00, 0x00, 0x08, 0x00}
-	epinen				uint32
-	epouten				uint32
-	easyDMABusy			volatile.Register8
-	epout0data_setlinecoding	bool
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func EnterOTABootloader
-
-```go
-func EnterOTABootloader()
-```
-
-EnterOTABootloader resets the chip into the bootloader so that it can be
-flashed via an OTA update
-
-
-### func EnterSerialBootloader
-
-```go
-func EnterSerialBootloader()
-```
-
-EnterSerialBootloader resets the chip into the serial bootloader. After
-reset, it can be flashed using serial/nrfutil.
-
-
-### func EnterUF2Bootloader
-
-```go
-func EnterUF2Bootloader()
-```
-
-EnterUF2Bootloader resets the chip into the UF2 bootloader. After reset, it
-can be flashed via nrfutil or by copying a UF2 file to the mass storage device
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the registers needed for ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the registers needed for PWM.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure() error
-```
-
-Configure configures an ADC pin to be able to read analog data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus *nrf.TWI_Type
-}
-```
-
-I2C on the NRF.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) (err error)
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure()
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *nrf.SPI_Type
-}
-```
-
-SPI on the NRF.
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the NRF.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer		*RingBuffer
-	interrupt	interrupt.Interrupt
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the nRF52840
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (*USBCDC) Configure
-
-```go
-func (usbcdc *USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/circuitplay-express.md b/content/microcontrollers/machine/circuitplay-express.md
deleted file mode 100644
index 17fefef7..00000000
--- a/content/microcontrollers/machine/circuitplay-express.md
+++ /dev/null
@@ -1,1641 +0,0 @@
-
----
-title: circuitplay-express
----
-
-
-## Constants
-
-```go
-const (
-	PA00	Pin	= 0
-	PA01	Pin	= 1
-	PA02	Pin	= 2
-	PA03	Pin	= 3
-	PA04	Pin	= 4
-	PA05	Pin	= 5
-	PA06	Pin	= 6
-	PA07	Pin	= 7
-	PA08	Pin	= 8
-	PA09	Pin	= 9
-	PA10	Pin	= 10
-	PA11	Pin	= 11
-	PA12	Pin	= 12
-	PA13	Pin	= 13
-	PA14	Pin	= 14
-	PA15	Pin	= 15
-	PA16	Pin	= 16
-	PA17	Pin	= 17
-	PA18	Pin	= 18
-	PA19	Pin	= 19
-	PA20	Pin	= 20
-	PA21	Pin	= 21
-	PA22	Pin	= 22
-	PA23	Pin	= 23
-	PA24	Pin	= 24
-	PA25	Pin	= 25
-	PA26	Pin	= 26
-	PA27	Pin	= 27
-	PA28	Pin	= 28
-	PA29	Pin	= 29
-	PA30	Pin	= 30
-	PA31	Pin	= 31
-	PB00	Pin	= 32
-	PB01	Pin	= 33
-	PB02	Pin	= 34
-	PB03	Pin	= 35
-	PB04	Pin	= 36
-	PB05	Pin	= 37
-	PB06	Pin	= 38
-	PB07	Pin	= 39
-	PB08	Pin	= 40
-	PB09	Pin	= 41
-	PB10	Pin	= 42
-	PB11	Pin	= 43
-	PB12	Pin	= 44
-	PB13	Pin	= 45
-	PB14	Pin	= 46
-	PB15	Pin	= 47
-	PB16	Pin	= 48
-	PB17	Pin	= 49
-	PB18	Pin	= 50
-	PB19	Pin	= 51
-	PB20	Pin	= 52
-	PB21	Pin	= 53
-	PB22	Pin	= 54
-	PB23	Pin	= 55
-	PB24	Pin	= 56
-	PB25	Pin	= 57
-	PB26	Pin	= 58
-	PB27	Pin	= 59
-	PB28	Pin	= 60
-	PB29	Pin	= 61
-	PB30	Pin	= 62
-	PB31	Pin	= 63
-)
-```
-
-Hardware pins
-
-
-```go
-const RESET_MAGIC_VALUE = 0xf01669ef
-```
-
-used to reset into bootloader
-
-
-```go
-const (
-	D0	= PB09
-	D1	= PB08
-	D2	= PB02
-	D3	= PB03
-	D4	= PA28
-	D5	= PA14
-	D6	= PA05
-	D7	= PA15
-	D8	= PB23
-	D9	= PA06
-	D10	= PA07
-	D11	= NoPin	// does not seem to exist
-	D12	= PA02
-	D13	= PA17	// PWM available
-)
-```
-
-GPIO Pins
-
-
-```go
-const (
-	A0	= PA02	// PWM available, also ADC/AIN[0]
-	A1	= PA05	// ADC/AIN[5]
-	A2	= PA06	// PWM available, also ADC/AIN[6]
-	A3	= PA07	// PWM available, also ADC/AIN[7]
-	A4	= PB03	// PORTB
-	A5	= PB02	// PORTB
-	A6	= PB09	// PORTB
-	A7	= PB08	// PORTB
-	A8	= PA11	// ADC/AIN[19]
-	A9	= PA09	// ADC/AIN[17]
-	A10	= PA04
-)
-```
-
-Analog Pins
-
-
-```go
-const (
-	LED		= D13
-	NEOPIXELS	= D8
-
-	BUTTONA	= D4
-	BUTTONB	= D5
-	SLIDER	= D7	// built-in slide switch
-
-	BUTTON	= BUTTONA
-	BUTTON1	= BUTTONB
-
-	LIGHTSENSOR	= A8
-	TEMPSENSOR	= A9
-	PROXIMITY	= A10
-)
-```
-
-
-
-```go
-const (
-	USBCDC_DM_PIN	= PA24
-	USBCDC_DP_PIN	= PA25
-)
-```
-
-USBCDC pins (logical UART0)
-
-
-```go
-const (
-	UART_TX_PIN	= PB08	// PORTB
-	UART_RX_PIN	= PB09	// PORTB
-)
-```
-
-UART0 pins (logical UART1)
-
-
-```go
-const (
-	SDA_PIN	= PB02	// I2C0 external
-	SCL_PIN	= PB03	// I2C0 external
-
-	SDA1_PIN	= PA00	// I2C1 internal
-	SCL1_PIN	= PA01	// I2C1 internal
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	= PA21	// SCK: SERCOM3/PAD[3]
-	SPI0_SDO_PIN	= PA20	// SDO: SERCOM3/PAD[2]
-	SPI0_SDI_PIN	= PA16	// SDI: SERCOM3/PAD[0]
-)
-```
-
-SPI pins (internal flash)
-
-
-```go
-const (
-	I2S_SCK_PIN	= PA10
-	I2S_SD_PIN	= PA08
-	I2S_WS_PIN	= NoPin	// no WS, instead uses SCK to sync
-)
-```
-
-I2S pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const (
-	I2SModeSource	I2SMode	= iota
-	I2SModeReceiver
-	I2SModePDM
-)
-```
-
-
-
-```go
-const (
-	I2StandardPhilips	I2SStandard	= iota
-	I2SStandardMSB
-	I2SStandardLSB
-)
-```
-
-
-
-```go
-const (
-	I2SClockSourceInternal	I2SClockSource	= iota
-	I2SClockSourceExternal
-)
-```
-
-
-
-```go
-const (
-	I2SDataFormatDefault	I2SDataFormat	= 0
-	I2SDataFormat8bit			= 8
-	I2SDataFormat16bit			= 16
-	I2SDataFormat24bit			= 24
-	I2SDataFormat32bit			= 32
-)
-```
-
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinAnalog	PinMode	= 1
-	PinSERCOM	PinMode	= 2
-	PinSERCOMAlt	PinMode	= 3
-	PinTimer	PinMode	= 4
-	PinTimerAlt	PinMode	= 5
-	PinCom		PinMode	= 6
-	//PinAC_CLK        PinMode = 7
-	PinDigital		PinMode	= 8
-	PinInput		PinMode	= 9
-	PinInputPullup		PinMode	= 10
-	PinOutput		PinMode	= 11
-	PinPWM			PinMode	= PinTimer
-	PinPWMAlt		PinMode	= PinTimerAlt
-	PinInputPulldown	PinMode	= 12
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
-	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
-	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	Mode0	= 0
-	Mode1	= 1
-	Mode2	= 2
-	Mode3	= 3
-)
-```
-
-SPI phase and polarity configs CPOL and CPHA
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART1 = UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	sam.SERCOM4_USART,
-		SERCOM:	4,
-	}
-)
-```
-
-UART1 on the Circuit Playground Express.
-
-
-```go
-var (
-	// external device
-	I2C0	= I2C{
-		Bus:	sam.SERCOM5_I2CM,
-		SERCOM:	5,
-	}
-	// internal device
-	I2C1	= I2C{
-		Bus:	sam.SERCOM1_I2CM,
-		SERCOM:	1,
-	}
-)
-```
-
-I2C on the Circuit Playground Express.
-
-
-```go
-var (
-	SPI0 = SPI{
-		Bus:	sam.SERCOM3_SPI,
-		SERCOM:	3,
-	}
-)
-```
-
-SPI on the Circuit Playground Express.
-
-
-```go
-var (
-	I2S0 = I2S{Bus: sam.I2S}
-)
-```
-
-I2S on the Circuit Playground Express.
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	// UART0 is actually a USB CDC interface.
-	UART0 = USBCDC{Buffer: NewRingBuffer()}
-)
-```
-
-
-
-```go
-var (
-	DAC0 = DAC{}
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-Return the current CPU frequency in hertz.
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the PWM interface.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-### func ResetProcessor
-
-```go
-func ResetProcessor()
-```
-
-ResetProcessor should perform a system reset in preperation
-to switch to the bootloader to flash new firmware.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure()
-```
-
-Configure configures a ADCPin to be able to be used to read data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin, in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DAC
-
-```go
-type DAC struct {
-}
-```
-
-DAC on the SAMD21.
-
-
-
-### func (DAC) Configure
-
-```go
-func (dac DAC) Configure(config DACConfig)
-```
-
-Configure the DAC.
-output pin must already be configured.
-
-
-### func (DAC) Set
-
-```go
-func (dac DAC) Set(value uint16) error
-```
-
-Set writes a single 16-bit value to the DAC.
-Since the ATSAMD21 only has a 10-bit DAC, the passed-in value will be scaled down.
-
-
-
-
-## type DACConfig
-
-```go
-type DACConfig struct {
-}
-```
-
-DACConfig placeholder for future expansion.
-
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus	*sam.SERCOM_I2CM_Type
-	SERCOM	uint8
-}
-```
-
-I2C on the SAMD21.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig) error
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) SetBaudRate
-
-```go
-func (i2c I2C) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the I2C.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteByte
-
-```go
-func (i2c I2C) WriteByte(data byte) error
-```
-
-WriteByte writes a single byte to the I2C bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type I2S
-
-```go
-type I2S struct {
-	Bus *sam.I2S_Type
-}
-```
-
-I2S
-
-
-
-### func (I2S) Close
-
-```go
-func (i2s I2S) Close() error
-```
-
-Close the I2S bus.
-
-
-### func (I2S) Configure
-
-```go
-func (i2s I2S) Configure(config I2SConfig)
-```
-
-Configure is used to configure the I2S interface. You must call this
-before you can use the I2S bus.
-
-
-### func (I2S) Read
-
-```go
-func (i2s I2S) Read(p []uint32) (n int, err error)
-```
-
-Read data from the I2S bus into the provided slice.
-The I2S bus must already have been configured correctly.
-
-
-### func (I2S) Write
-
-```go
-func (i2s I2S) Write(p []uint32) (n int, err error)
-```
-
-Write data to the I2S bus from the provided slice.
-The I2S bus must already have been configured correctly.
-
-
-
-
-## type I2SClockSource
-
-```go
-type I2SClockSource uint8
-```
-
-
-
-
-
-
-## type I2SConfig
-
-```go
-type I2SConfig struct {
-	SCK		Pin
-	WS		Pin
-	SD		Pin
-	Mode		I2SMode
-	Standard	I2SStandard
-	ClockSource	I2SClockSource
-	DataFormat	I2SDataFormat
-	AudioFrequency	uint32
-	MainClockOutput	bool
-	Stereo		bool
-}
-```
-
-All fields are optional and may not be required or used on a particular platform.
-
-
-
-
-
-## type I2SDataFormat
-
-```go
-type I2SDataFormat uint8
-```
-
-
-
-
-
-
-## type I2SMode
-
-```go
-type I2SMode uint8
-```
-
-
-
-
-
-
-## type I2SStandard
-
-```go
-type I2SStandard uint8
-```
-
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure() error
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus	*sam.SERCOM_SPI_Type
-	SERCOM	uint8
-}
-```
-
-SPI
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig) error
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer		*RingBuffer
-	Bus		*sam.SERCOM_USART_Type
-	SERCOM		uint8
-	Interrupt	interrupt.Interrupt
-}
-```
-
-UART on the SAMD21.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig) error
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer *RingBuffer
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the SAMD21.
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (USBCDC) Configure
-
-```go
-func (usbcdc USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/clue-alpha.md b/content/microcontrollers/machine/clue-alpha.md
deleted file mode 100644
index 0e580802..00000000
--- a/content/microcontrollers/machine/clue-alpha.md
+++ /dev/null
@@ -1,1424 +0,0 @@
-
----
-title: clue-alpha
----
-
-
-## Constants
-
-```go
-const HasLowFrequencyCrystal = true
-```
-
-
-
-```go
-const (
-	D0	= P0_04
-	D1	= P0_05
-	D2	= P0_03
-	D3	= P0_28
-	D4	= P0_02
-	D5	= P1_02
-	D6	= P1_09
-	D7	= P0_07
-	D8	= P1_07
-	D9	= P0_27
-	D10	= P0_30
-	D11	= P1_10
-	D12	= P0_31
-	D13	= P0_08
-	D14	= P0_06
-	D15	= P0_26
-	D16	= P0_29
-	D17	= P1_01
-	D18	= P0_16
-	D19	= P0_25
-	D20	= P0_24
-	D21	= A0
-	D22	= A1
-	D23	= A2
-	D24	= A3
-	D25	= A4
-	D26	= A5
-	D27	= A6
-	D28	= A7
-	D29	= P0_14
-	D30	= P0_15
-	D31	= P0_12
-	D32	= P0_13
-	D33	= P1_03
-	D34	= P1_05
-	D35	= P0_00
-	D36	= P0_01
-	D37	= P0_19
-	D38	= P0_20
-	D39	= P0_17
-	D40	= P0_22
-	D41	= P0_23
-	D42	= P0_21
-	D43	= P0_10
-	D44	= P0_09
-	D45	= P1_06
-	D46	= P1_00
-)
-```
-
-GPIO Pins
-
-
-```go
-const (
-	A0	= D12
-	A1	= D16
-	A2	= D0
-	A3	= D1
-	A4	= D2
-	A5	= D3
-	A6	= D4
-	A7	= D10
-)
-```
-
-Analog Pins
-
-
-```go
-const (
-	LED		= D17
-	LED1		= LED
-	LED2		= D43
-	NEOPIXEL	= D18
-
-	BUTTON_LEFT	= D5
-	BUTTON_RIGHT	= D11
-
-	// 240x240 ST7789 display is connected to these pins (use RowOffset = 80)
-	TFT_SCK		= D29
-	TFT_SDO		= D30
-	TFT_CS		= D31
-	TFT_DC		= D32
-	TFT_RESET	= D33
-	TFT_LITE	= D34
-
-	PDM_DAT	= D35
-	PDM_CLK	= D36
-
-	QSPI_SCK	= D37
-	QSPI_CS		= D38
-	QSPI_DATA0	= D39
-	QSPI_DATA1	= D40
-	QSPI_DATA2	= D41
-	QSPI_DATA3	= D42
-
-	SPEAKER	= D46
-)
-```
-
-
-
-```go
-const (
-	UART_RX_PIN	= D0
-	UART_TX_PIN	= D1
-)
-```
-
-UART0 pins (logical UART1)
-
-
-```go
-const (
-	SDA_PIN	= D20	// I2C0 external
-	SCL_PIN	= D19	// I2C0 external
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	= D13	// SCK
-	SPI0_SDO_PIN	= D15	// SDO
-	SPI0_SDI_PIN	= D14	// SDI
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Disconnect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
-	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
-	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	P0_00	Pin	= 0
-	P0_01	Pin	= 1
-	P0_02	Pin	= 2
-	P0_03	Pin	= 3
-	P0_04	Pin	= 4
-	P0_05	Pin	= 5
-	P0_06	Pin	= 6
-	P0_07	Pin	= 7
-	P0_08	Pin	= 8
-	P0_09	Pin	= 9
-	P0_10	Pin	= 10
-	P0_11	Pin	= 11
-	P0_12	Pin	= 12
-	P0_13	Pin	= 13
-	P0_14	Pin	= 14
-	P0_15	Pin	= 15
-	P0_16	Pin	= 16
-	P0_17	Pin	= 17
-	P0_18	Pin	= 18
-	P0_19	Pin	= 19
-	P0_20	Pin	= 20
-	P0_21	Pin	= 21
-	P0_22	Pin	= 22
-	P0_23	Pin	= 23
-	P0_24	Pin	= 24
-	P0_25	Pin	= 25
-	P0_26	Pin	= 26
-	P0_27	Pin	= 27
-	P0_28	Pin	= 28
-	P0_29	Pin	= 29
-	P0_30	Pin	= 30
-	P0_31	Pin	= 31
-	P1_00	Pin	= 32
-	P1_01	Pin	= 33
-	P1_02	Pin	= 34
-	P1_03	Pin	= 35
-	P1_04	Pin	= 36
-	P1_05	Pin	= 37
-	P1_06	Pin	= 38
-	P1_07	Pin	= 39
-	P1_08	Pin	= 40
-	P1_09	Pin	= 41
-	P1_10	Pin	= 42
-	P1_11	Pin	= 43
-	P1_12	Pin	= 44
-	P1_13	Pin	= 45
-	P1_14	Pin	= 46
-	P1_15	Pin	= 47
-)
-```
-
-Hardware pins
-
-
-```go
-const (
-	DFU_MAGIC_SERIAL_ONLY_RESET	= 0x4e
-	DFU_MAGIC_UF2_RESET		= 0x57
-	DFU_MAGIC_OTA_RESET		= 0xA8
-)
-```
-
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART0 = USB
-)
-```
-
-UART0 is the USB device
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-```go
-var (
-	// NRF_UART0 is the hardware UART on the NRF SoC.
-	NRF_UART0 = UART{Buffer: NewRingBuffer()}
-)
-```
-
-UART
-
-
-```go
-var (
-	I2C0	= I2C{Bus: nrf.TWI0}
-	I2C1	= I2C{Bus: nrf.TWI1}
-)
-```
-
-There are 2 I2C interfaces on the NRF.
-
-
-```go
-var (
-	SPI0	= SPI{Bus: nrf.SPI0}
-	SPI1	= SPI{Bus: nrf.SPI1}
-)
-```
-
-There are 2 SPI interfaces on the NRF5x.
-
-
-```go
-var (
-	USB	= USBCDC{Buffer: NewRingBuffer()}
-
-	usbEndpointDescriptors	[8]usbDeviceDescriptor
-
-	udd_ep_in_cache_buffer	[7][128]uint8
-	udd_ep_out_cache_buffer	[7][128]uint8
-
-	sendOnEP0DATADONE	struct {
-		ptr	*byte
-		count	int
-	}
-	isEndpointHalt		= false
-	isRemoteWakeUpEnabled	= false
-	endPoints		= []uint32{usb_ENDPOINT_TYPE_CONTROL,
-		(usb_ENDPOINT_TYPE_INTERRUPT | usbEndpointIn),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointOut),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointIn)}
-
-	usbConfiguration		uint8
-	usbSetInterface			uint8
-	usbLineInfo			= cdcLineInfo{115200, 0x00, 0x00, 0x08, 0x00}
-	epinen				uint32
-	epouten				uint32
-	easyDMABusy			volatile.Register8
-	epout0data_setlinecoding	bool
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func EnterOTABootloader
-
-```go
-func EnterOTABootloader()
-```
-
-EnterOTABootloader resets the chip into the bootloader so that it can be
-flashed via an OTA update
-
-
-### func EnterSerialBootloader
-
-```go
-func EnterSerialBootloader()
-```
-
-EnterSerialBootloader resets the chip into the serial bootloader. After
-reset, it can be flashed using serial/nrfutil.
-
-
-### func EnterUF2Bootloader
-
-```go
-func EnterUF2Bootloader()
-```
-
-EnterUF2Bootloader resets the chip into the UF2 bootloader. After reset, it
-can be flashed via nrfutil or by copying a UF2 file to the mass storage device
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the registers needed for ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the registers needed for PWM.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure() error
-```
-
-Configure configures an ADC pin to be able to read analog data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus *nrf.TWI_Type
-}
-```
-
-I2C on the NRF.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) (err error)
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure()
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *nrf.SPI_Type
-}
-```
-
-SPI on the NRF.
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the NRF.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer		*RingBuffer
-	interrupt	interrupt.Interrupt
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the nRF52840
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (*USBCDC) Configure
-
-```go
-func (usbcdc *USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/clue_alpha.md b/content/microcontrollers/machine/clue_alpha.md
deleted file mode 100644
index 9f4ac990..00000000
--- a/content/microcontrollers/machine/clue_alpha.md
+++ /dev/null
@@ -1,1423 +0,0 @@
-
----
-title: clue_alpha
----
-
-
-## Constants
-
-```go
-const HasLowFrequencyCrystal = true
-```
-
-
-
-```go
-const (
-	D0	= P0_04
-	D1	= P0_05
-	D2	= P0_03
-	D3	= P0_28
-	D4	= P0_02
-	D5	= P1_02
-	D6	= P1_09
-	D7	= P0_07
-	D8	= P1_07
-	D9	= P0_27
-	D10	= P0_30
-	D11	= P1_10
-	D12	= P0_31
-	D13	= P0_08
-	D14	= P0_06
-	D15	= P0_26
-	D16	= P0_29
-	D17	= P1_01
-	D18	= P0_16
-	D19	= P0_25
-	D20	= P0_24
-	D21	= A0
-	D22	= A1
-	D23	= A2
-	D24	= A3
-	D25	= A4
-	D26	= A5
-	D27	= A6
-	D28	= A7
-	D29	= P0_14
-	D30	= P0_15
-	D31	= P0_12
-	D32	= P0_13
-	D33	= P1_03
-	D34	= P1_05
-	D35	= P0_00
-	D36	= P0_01
-	D37	= P0_19
-	D38	= P0_20
-	D39	= P0_17
-	D40	= P0_22
-	D41	= P0_23
-	D42	= P0_21
-	D43	= P0_10
-	D44	= P0_09
-	D45	= P1_06
-	D46	= P1_00
-)
-```
-
-GPIO Pins
-
-
-```go
-const (
-	A0	= D12
-	A1	= D16
-	A2	= D0
-	A3	= D1
-	A4	= D2
-	A5	= D3
-	A6	= D4
-	A7	= D10
-)
-```
-
-Analog Pins
-
-
-```go
-const (
-	LED		= D17
-	LED1		= LED
-	LED2		= D43
-	NEOPIXEL	= D18
-
-	BUTTON_LEFT	= D5
-	BUTTON_RIGHT	= D11
-
-	// 240x240 ST7789 display is connected to these pins (use RowOffset = 80)
-	TFT_SCK		= D29
-	TFT_SDO		= D30
-	TFT_CS		= D31
-	TFT_DC		= D32
-	TFT_RESET	= D33
-	TFT_LITE	= D34
-
-	PDM_DAT	= D35
-	PDM_CLK	= D36
-
-	QSPI_SCK	= D37
-	QSPI_CS		= D38
-	QSPI_DATA0	= D39
-	QSPI_DATA1	= D40
-	QSPI_DATA2	= D41
-	QSPI_DATA3	= D42
-
-	SPEAKER	= D46
-)
-```
-
-
-
-```go
-const (
-	UART_RX_PIN	= D0
-	UART_TX_PIN	= D1
-)
-```
-
-UART0 pins (logical UART1)
-
-
-```go
-const (
-	SDA_PIN	= D20	// I2C0 external
-	SCL_PIN	= D19	// I2C0 external
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	= D13	// SCK
-	SPI0_SDO_PIN	= D15	// SDO
-	SPI0_SDI_PIN	= D14	// SDI
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Disconnect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
-	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
-	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	P0_00	Pin	= 0
-	P0_01	Pin	= 1
-	P0_02	Pin	= 2
-	P0_03	Pin	= 3
-	P0_04	Pin	= 4
-	P0_05	Pin	= 5
-	P0_06	Pin	= 6
-	P0_07	Pin	= 7
-	P0_08	Pin	= 8
-	P0_09	Pin	= 9
-	P0_10	Pin	= 10
-	P0_11	Pin	= 11
-	P0_12	Pin	= 12
-	P0_13	Pin	= 13
-	P0_14	Pin	= 14
-	P0_15	Pin	= 15
-	P0_16	Pin	= 16
-	P0_17	Pin	= 17
-	P0_18	Pin	= 18
-	P0_19	Pin	= 19
-	P0_20	Pin	= 20
-	P0_21	Pin	= 21
-	P0_22	Pin	= 22
-	P0_23	Pin	= 23
-	P0_24	Pin	= 24
-	P0_25	Pin	= 25
-	P0_26	Pin	= 26
-	P0_27	Pin	= 27
-	P0_28	Pin	= 28
-	P0_29	Pin	= 29
-	P0_30	Pin	= 30
-	P0_31	Pin	= 31
-	P1_00	Pin	= 32
-	P1_01	Pin	= 33
-	P1_02	Pin	= 34
-	P1_03	Pin	= 35
-	P1_04	Pin	= 36
-	P1_05	Pin	= 37
-	P1_06	Pin	= 38
-	P1_07	Pin	= 39
-	P1_08	Pin	= 40
-	P1_09	Pin	= 41
-	P1_10	Pin	= 42
-	P1_11	Pin	= 43
-	P1_12	Pin	= 44
-	P1_13	Pin	= 45
-	P1_14	Pin	= 46
-	P1_15	Pin	= 47
-)
-```
-
-Hardware pins
-
-
-```go
-const (
-	DFU_MAGIC_SERIAL_ONLY_RESET	= 0x4e
-	DFU_MAGIC_UF2_RESET		= 0x57
-	DFU_MAGIC_OTA_RESET		= 0xA8
-)
-```
-
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART0 = USB
-)
-```
-
-UART0 is the USB device
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-```go
-var (
-	// NRF_UART0 is the hardware UART on the NRF SoC.
-	NRF_UART0 = UART{Buffer: NewRingBuffer()}
-)
-```
-
-UART
-
-
-```go
-var (
-	I2C0	= I2C{Bus: nrf.TWI0}
-	I2C1	= I2C{Bus: nrf.TWI1}
-)
-```
-
-There are 2 I2C interfaces on the NRF.
-
-
-```go
-var (
-	SPI0	= SPI{Bus: nrf.SPI0}
-	SPI1	= SPI{Bus: nrf.SPI1}
-)
-```
-
-There are 2 SPI interfaces on the NRF5x.
-
-
-```go
-var (
-	USB	= USBCDC{Buffer: NewRingBuffer()}
-
-	usbEndpointDescriptors	[8]usbDeviceDescriptor
-
-	udd_ep_in_cache_buffer	[7][128]uint8
-	udd_ep_out_cache_buffer	[7][128]uint8
-
-	sendOnEP0DATADONE	struct {
-		ptr	*byte
-		count	int
-	}
-	isEndpointHalt		= false
-	isRemoteWakeUpEnabled	= false
-	endPoints		= []uint32{usb_ENDPOINT_TYPE_CONTROL,
-		(usb_ENDPOINT_TYPE_INTERRUPT | usbEndpointIn),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointOut),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointIn)}
-
-	usbConfiguration		uint8
-	usbSetInterface			uint8
-	usbLineInfo			= cdcLineInfo{115200, 0x00, 0x00, 0x08, 0x00}
-	epinen				uint32
-	epouten				uint32
-	easyDMABusy			volatile.Register8
-	epout0data_setlinecoding	bool
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func EnterOTABootloader
-
-```go
-func EnterOTABootloader()
-```
-
-EnterOTABootloader resets the chip into the bootloader so that it can be
-flashed via an OTA update
-
-
-### func EnterSerialBootloader
-
-```go
-func EnterSerialBootloader()
-```
-
-EnterSerialBootloader resets the chip into the serial bootloader. After
-reset, it can be flashed using serial/nrfutil.
-
-
-### func EnterUF2Bootloader
-
-```go
-func EnterUF2Bootloader()
-```
-
-EnterUF2Bootloader resets the chip into the UF2 bootloader. After reset, it
-can be flashed via nrfutil or by copying a UF2 file to the mass storage device
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the registers needed for ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the registers needed for PWM.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure() error
-```
-
-Configure configures an ADC pin to be able to read analog data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus *nrf.TWI_Type
-}
-```
-
-I2C on the NRF.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure()
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *nrf.SPI_Type
-}
-```
-
-SPI on the NRF.
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the NRF.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer		*RingBuffer
-	interrupt	interrupt.Interrupt
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the nRF52840
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (*USBCDC) Configure
-
-```go
-func (usbcdc *USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/cortex-m-qemu.md b/content/microcontrollers/machine/cortex-m-qemu.md
deleted file mode 100644
index c6d640e6..00000000
--- a/content/microcontrollers/machine/cortex-m-qemu.md
+++ /dev/null
@@ -1,177 +0,0 @@
-
----
-title: cortex-m-qemu
----
-
-
-## Constants
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-
-
-
-## Variables
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
diff --git a/content/microcontrollers/machine/d1mini.md b/content/microcontrollers/machine/d1mini.md
deleted file mode 100644
index 9f6f36fd..00000000
--- a/content/microcontrollers/machine/d1mini.md
+++ /dev/null
@@ -1,415 +0,0 @@
-
----
-title: d1mini
----
-
-
-## Constants
-
-```go
-const (
-	D0	Pin	= 16
-	D1	Pin	= 5
-	D2	Pin	= 4
-	D3	Pin	= 0
-	D4	Pin	= 2
-	D5	Pin	= 14
-	D6	Pin	= 12
-	D7	Pin	= 13
-	D8	Pin	= 15
-)
-```
-
-GPIO pins on the NodeMCU board.
-
-
-```go
-const LED = D4
-```
-
-Onboard blue LED (on the AI-Thinker module).
-
-
-```go
-const (
-	SPI0_SCK_PIN	= D5
-	SPI0_SDO_PIN	= D7
-	SPI0_SDI_PIN	= D6
-	SPI0_CS0_PIN	= D8
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	SDA_PIN	= D2
-	SCL_PIN	= D1
-)
-```
-
-I2C pins
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinOutput	PinMode	= iota
-	PinInput
-)
-```
-
-
-
-```go
-const (
-	UART_TX_PIN	Pin	= 1
-	UART_RX_PIN	Pin	= 3
-)
-```
-
-Pins that are fixed by the chip.
-
-
-
-
-
-## Variables
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var UART0 = UART{Buffer: NewRingBuffer()}
-```
-
-UART0 is a hardware UART that supports both TX and RX.
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure sets the given pin as output or input pin.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin when the pin is configured as an
-input.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-Warning: only use this on an output pin!
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-Warning: only use this on an output pin!
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(value bool)
-```
-
-Set sets the output value of this pin to high (true) or low (false).
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART baud rate. TX and RX pins are fixed by the hardware so
-cannot be modified and will be ignored.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a single byte to the output buffer. Note that the hardware
-includes a buffer of 128 bytes which will be used first.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/esp32-coreboard-v2.md b/content/microcontrollers/machine/esp32-coreboard-v2.md
deleted file mode 100644
index eb034712..00000000
--- a/content/microcontrollers/machine/esp32-coreboard-v2.md
+++ /dev/null
@@ -1,568 +0,0 @@
-
----
-title: esp32-coreboard-v2
----
-
-
-## Constants
-
-```go
-const LED = IO2
-```
-
-Built-in LED on some ESP32 boards.
-
-
-```go
-const (
-	CLK	Pin	= 6
-	CMD	Pin	= 11
-	IO0	Pin	= 0
-	IO1	Pin	= 1
-	IO10	Pin	= 10
-	IO16	Pin	= 16
-	IO17	Pin	= 17
-	IO18	Pin	= 18
-	IO19	Pin	= 19
-	IO2	Pin	= 2
-	IO21	Pin	= 21
-	IO22	Pin	= 22
-	IO23	Pin	= 23
-	IO25	Pin	= 25
-	IO26	Pin	= 26
-	IO27	Pin	= 27
-	IO3	Pin	= 3
-	IO32	Pin	= 32
-	IO33	Pin	= 33
-	IO34	Pin	= 34
-	IO35	Pin	= 35
-	IO36	Pin	= 36
-	IO39	Pin	= 39
-	IO4	Pin	= 4
-	IO5	Pin	= 5
-	IO9	Pin	= 9
-	RXD	Pin	= 3
-	SD0	Pin	= 7
-	SD1	Pin	= 8
-	SD2	Pin	= 9
-	SD3	Pin	= 10
-	SVN	Pin	= 39
-	SVP	Pin	= 36
-	TCK	Pin	= 13
-	TD0	Pin	= 15
-	TDI	Pin	= 12
-	TMS	Pin	= 14
-	TXD	Pin	= 1
-)
-```
-
-
-
-```go
-const (
-	SPI0_SCK_PIN	= IO18
-	SPI0_SDO_PIN	= IO23
-	SPI0_SDI_PIN	= IO19
-	SPI0_CS0_PIN	= IO5
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	SDA_PIN	= IO21
-	SCL_PIN	= IO22
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	ADC0	Pin	= IO34
-	ADC1	Pin	= IO35
-	ADC2	Pin	= IO36
-	ADC3	Pin	= IO39
-)
-```
-
-ADC pins
-
-
-```go
-const (
-	UART_TX_PIN	= IO1
-	UART_RX_PIN	= IO3
-)
-```
-
-UART0 pins
-
-
-```go
-const (
-	UART1_TX_PIN	= IO9
-	UART1_RX_PIN	= IO10
-)
-```
-
-UART1 pins
-
-
-```go
-const (
-	PWM0_PIN	Pin	= IO2
-	PWM1_PIN	Pin	= IO0
-	PWM2_PIN	Pin	= IO4
-)
-```
-
-PWM pins
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinOutput	PinMode	= iota
-	PinInput
-	PinInputPullup
-	PinInputPulldown
-)
-```
-
-
-
-
-
-
-## Variables
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrInvalidSPIBus = errors.New("machine: invalid SPI bus")
-)
-```
-
-
-
-```go
-var (
-	UART0	= UART{Bus: esp.UART0, Buffer: NewRingBuffer()}
-	UART1	= UART{Bus: esp.UART1, Buffer: NewRingBuffer()}
-	UART2	= UART{Bus: esp.UART2, Buffer: NewRingBuffer()}
-)
-```
-
-
-
-```go
-var (
-	// SPI0 and SPI1 are reserved for use by the caching system etc.
-	SPI2	= SPI{esp.SPI2}
-	SPI3	= SPI{esp.SPI3}
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-CPUFrequency returns the current CPU frequency of the chip.
-Currently it is a fixed frequency but it may allow changing in the future.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin when the pin is configured as an
-input.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-Warning: only use this on an output pin!
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-Warning: only use this on an output pin!
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(value bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *esp.SPI_Type
-}
-```
-
-Serial Peripheral Interface on the ESP32.
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig) error
-```
-
-Configure and make the SPI peripheral ready to use.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface. If you need to
-transfer larger amounts of data, Tx will be faster.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-This is accomplished by sending zero bits if r is bigger than w or discarding
-the incoming data if w is bigger than r.
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig configures a SPI peripheral on the ESP32. Make sure to set at least
-SCK, SDO and SDI (possibly to NoPin if not in use). The default for LSBFirst
-(false) and Mode (0) are good for most applications. The frequency defaults
-to 1MHz if not set but can be configured up to 40MHz. Possible values are
-40MHz and integer divisions from 40MHz such as 20MHz, 13.3MHz, 10MHz, 8MHz,
-etc.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Bus	*esp.UART_Type
-	Buffer	*RingBuffer
-}
-```
-
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(b byte) error
-```
-
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/esp32-mini32.md b/content/microcontrollers/machine/esp32-mini32.md
deleted file mode 100644
index 17dae035..00000000
--- a/content/microcontrollers/machine/esp32-mini32.md
+++ /dev/null
@@ -1,568 +0,0 @@
-
----
-title: esp32-mini32
----
-
-
-## Constants
-
-```go
-const LED = IO2
-```
-
-Built-in LED on some ESP32 boards.
-
-
-```go
-const (
-	CLK	Pin	= 6
-	CMD	Pin	= 11
-	IO0	Pin	= 0
-	IO1	Pin	= 1
-	IO10	Pin	= 10
-	IO16	Pin	= 16
-	IO17	Pin	= 17
-	IO18	Pin	= 18
-	IO19	Pin	= 19
-	IO2	Pin	= 2
-	IO21	Pin	= 21
-	IO22	Pin	= 22
-	IO23	Pin	= 23
-	IO25	Pin	= 25
-	IO26	Pin	= 26
-	IO27	Pin	= 27
-	IO3	Pin	= 3
-	IO32	Pin	= 32
-	IO33	Pin	= 33
-	IO34	Pin	= 34
-	IO35	Pin	= 35
-	IO36	Pin	= 36
-	IO39	Pin	= 39
-	IO4	Pin	= 4
-	IO5	Pin	= 5
-	IO9	Pin	= 9
-	RXD	Pin	= 3
-	SD0	Pin	= 7
-	SD1	Pin	= 8
-	SD2	Pin	= 9
-	SD3	Pin	= 10
-	SVN	Pin	= 39
-	SVP	Pin	= 36
-	TCK	Pin	= 13
-	TD0	Pin	= 15
-	TDI	Pin	= 12
-	TMS	Pin	= 14
-	TXD	Pin	= 1
-)
-```
-
-
-
-```go
-const (
-	SPI0_SCK_PIN	= IO18
-	SPI0_SDO_PIN	= IO23
-	SPI0_SDI_PIN	= IO19
-	SPI0_CS0_PIN	= IO5
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	SDA_PIN	= IO21
-	SCL_PIN	= IO22
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	ADC0	Pin	= IO34
-	ADC1	Pin	= IO35
-	ADC2	Pin	= IO36
-	ADC3	Pin	= IO39
-)
-```
-
-ADC pins
-
-
-```go
-const (
-	UART_TX_PIN	= IO1
-	UART_RX_PIN	= IO3
-)
-```
-
-UART0 pins
-
-
-```go
-const (
-	UART1_TX_PIN	= IO9
-	UART1_RX_PIN	= IO10
-)
-```
-
-UART1 pins
-
-
-```go
-const (
-	PWM0_PIN	Pin	= IO2
-	PWM1_PIN	Pin	= IO0
-	PWM2_PIN	Pin	= IO4
-)
-```
-
-PWM pins
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinOutput	PinMode	= iota
-	PinInput
-	PinInputPullup
-	PinInputPulldown
-)
-```
-
-
-
-
-
-
-## Variables
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrInvalidSPIBus = errors.New("machine: invalid SPI bus")
-)
-```
-
-
-
-```go
-var (
-	UART0	= UART{Bus: esp.UART0, Buffer: NewRingBuffer()}
-	UART1	= UART{Bus: esp.UART1, Buffer: NewRingBuffer()}
-	UART2	= UART{Bus: esp.UART2, Buffer: NewRingBuffer()}
-)
-```
-
-
-
-```go
-var (
-	// SPI0 and SPI1 are reserved for use by the caching system etc.
-	SPI2	= SPI{esp.SPI2}
-	SPI3	= SPI{esp.SPI3}
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-CPUFrequency returns the current CPU frequency of the chip.
-Currently it is a fixed frequency but it may allow changing in the future.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin when the pin is configured as an
-input.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-Warning: only use this on an output pin!
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-Warning: only use this on an output pin!
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(value bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *esp.SPI_Type
-}
-```
-
-Serial Peripheral Interface on the ESP32.
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig) error
-```
-
-Configure and make the SPI peripheral ready to use.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface. If you need to
-transfer larger amounts of data, Tx will be faster.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-This is accomplished by sending zero bits if r is bigger than w or discarding
-the incoming data if w is bigger than r.
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig configures a SPI peripheral on the ESP32. Make sure to set at least
-SCK, SDO and SDI (possibly to NoPin if not in use). The default for LSBFirst
-(false) and Mode (0) are good for most applications. The frequency defaults
-to 1MHz if not set but can be configured up to 40MHz. Possible values are
-40MHz and integer divisions from 40MHz such as 20MHz, 13.3MHz, 10MHz, 8MHz,
-etc.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Bus	*esp.UART_Type
-	Buffer	*RingBuffer
-}
-```
-
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(b byte) error
-```
-
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/esp32.md b/content/microcontrollers/machine/esp32.md
deleted file mode 100644
index fa07d925..00000000
--- a/content/microcontrollers/machine/esp32.md
+++ /dev/null
@@ -1,451 +0,0 @@
-
----
-title: esp32
----
-
-
-## Constants
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinOutput	PinMode	= iota
-	PinInput
-	PinInputPullup
-	PinInputPulldown
-)
-```
-
-
-
-
-
-
-## Variables
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrInvalidSPIBus = errors.New("machine: invalid SPI bus")
-)
-```
-
-
-
-```go
-var (
-	UART0	= UART{Bus: esp.UART0, Buffer: NewRingBuffer()}
-	UART1	= UART{Bus: esp.UART1, Buffer: NewRingBuffer()}
-	UART2	= UART{Bus: esp.UART2, Buffer: NewRingBuffer()}
-)
-```
-
-
-
-```go
-var (
-	// SPI0 and SPI1 are reserved for use by the caching system etc.
-	SPI2	= SPI{esp.SPI2}
-	SPI3	= SPI{esp.SPI3}
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-CPUFrequency returns the current CPU frequency of the chip.
-Currently it is a fixed frequency but it may allow changing in the future.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin when the pin is configured as an
-input.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-Warning: only use this on an output pin!
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-Warning: only use this on an output pin!
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(value bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *esp.SPI_Type
-}
-```
-
-Serial Peripheral Interface on the ESP32.
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig) error
-```
-
-Configure and make the SPI peripheral ready to use.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface. If you need to
-transfer larger amounts of data, Tx will be faster.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-This is accomplished by sending zero bits if r is bigger than w or discarding
-the incoming data if w is bigger than r.
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig configures a SPI peripheral on the ESP32. Make sure to set at least
-SCK, SDO and SDI (possibly to NoPin if not in use). The default for LSBFirst
-(false) and Mode (0) are good for most applications. The frequency defaults
-to 1MHz if not set but can be configured up to 40MHz. Possible values are
-40MHz and integer divisions from 40MHz such as 20MHz, 13.3MHz, 10MHz, 8MHz,
-etc.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Bus	*esp.UART_Type
-	Buffer	*RingBuffer
-}
-```
-
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(b byte) error
-```
-
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/esp8266.md b/content/microcontrollers/machine/esp8266.md
deleted file mode 100644
index 420cc750..00000000
--- a/content/microcontrollers/machine/esp8266.md
+++ /dev/null
@@ -1,369 +0,0 @@
-
----
-title: esp8266
----
-
-
-## Constants
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinOutput	PinMode	= iota
-	PinInput
-)
-```
-
-
-
-```go
-const (
-	UART_TX_PIN	Pin	= 1
-	UART_RX_PIN	Pin	= 3
-)
-```
-
-Pins that are fixed by the chip.
-
-
-
-
-
-## Variables
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var UART0 = UART{Buffer: NewRingBuffer()}
-```
-
-UART0 is a hardware UART that supports both TX and RX.
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure sets the given pin as output or input pin.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin when the pin is configured as an
-input.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-Warning: only use this on an output pin!
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-Warning: only use this on an output pin!
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(value bool)
-```
-
-Set sets the output value of this pin to high (true) or low (false).
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART baud rate. TX and RX pins are fixed by the hardware so
-cannot be modified and will be ignored.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a single byte to the output buffer. Note that the hardware
-includes a buffer of 128 bytes which will be used first.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/feather-m0.md b/content/microcontrollers/machine/feather-m0.md
deleted file mode 100644
index 9002606c..00000000
--- a/content/microcontrollers/machine/feather-m0.md
+++ /dev/null
@@ -1,1606 +0,0 @@
-
----
-title: feather-m0
----
-
-
-## Constants
-
-```go
-const (
-	PA00	Pin	= 0
-	PA01	Pin	= 1
-	PA02	Pin	= 2
-	PA03	Pin	= 3
-	PA04	Pin	= 4
-	PA05	Pin	= 5
-	PA06	Pin	= 6
-	PA07	Pin	= 7
-	PA08	Pin	= 8
-	PA09	Pin	= 9
-	PA10	Pin	= 10
-	PA11	Pin	= 11
-	PA12	Pin	= 12
-	PA13	Pin	= 13
-	PA14	Pin	= 14
-	PA15	Pin	= 15
-	PA16	Pin	= 16
-	PA17	Pin	= 17
-	PA18	Pin	= 18
-	PA19	Pin	= 19
-	PA20	Pin	= 20
-	PA21	Pin	= 21
-	PA22	Pin	= 22
-	PA23	Pin	= 23
-	PA24	Pin	= 24
-	PA25	Pin	= 25
-	PA26	Pin	= 26
-	PA27	Pin	= 27
-	PA28	Pin	= 28
-	PA29	Pin	= 29
-	PA30	Pin	= 30
-	PA31	Pin	= 31
-	PB00	Pin	= 32
-	PB01	Pin	= 33
-	PB02	Pin	= 34
-	PB03	Pin	= 35
-	PB04	Pin	= 36
-	PB05	Pin	= 37
-	PB06	Pin	= 38
-	PB07	Pin	= 39
-	PB08	Pin	= 40
-	PB09	Pin	= 41
-	PB10	Pin	= 42
-	PB11	Pin	= 43
-	PB12	Pin	= 44
-	PB13	Pin	= 45
-	PB14	Pin	= 46
-	PB15	Pin	= 47
-	PB16	Pin	= 48
-	PB17	Pin	= 49
-	PB18	Pin	= 50
-	PB19	Pin	= 51
-	PB20	Pin	= 52
-	PB21	Pin	= 53
-	PB22	Pin	= 54
-	PB23	Pin	= 55
-	PB24	Pin	= 56
-	PB25	Pin	= 57
-	PB26	Pin	= 58
-	PB27	Pin	= 59
-	PB28	Pin	= 60
-	PB29	Pin	= 61
-	PB30	Pin	= 62
-	PB31	Pin	= 63
-)
-```
-
-Hardware pins
-
-
-```go
-const RESET_MAGIC_VALUE = 0xf01669ef
-```
-
-used to reset into bootloader
-
-
-```go
-const (
-	D0	= PA11	// UART0 RX
-	D1	= PA10	// UART0 TX
-	D2	= NoPin	// does not seem to exist
-	D3	= PA09
-	D4	= PA08
-	D5	= PA15	// PWM available
-	D6	= PA20	// PWM available
-	D7	= NoPin	// does not seem to exist
-	D8	= PA06
-	D9	= PA07	// PWM available
-	D10	= PA18	// can be used for PWM or UART1 TX
-	D11	= PA16	// can be used for PWM or UART1 RX
-	D12	= PA19	// PWM available
-	D13	= PA17	// PWM available
-)
-```
-
-GPIO Pins
-
-
-```go
-const (
-	A0	= PA02	// ADC/AIN[0]
-	A1	= PB08	// ADC/AIN[2]
-	A2	= PB09	// ADC/AIN[3]
-	A3	= PA04	// ADC/AIN[4]
-	A4	= PA05	// ADC/AIN[5]
-	A5	= PB02	// ADC/AIN[10]
-)
-```
-
-Analog pins
-
-
-```go
-const (
-	LED = D13
-)
-```
-
-
-
-```go
-const (
-	USBCDC_DM_PIN	= PA24
-	USBCDC_DP_PIN	= PA25
-)
-```
-
-UART0 aka USBCDC pins
-
-
-```go
-const (
-	UART_TX_PIN	= D10
-	UART_RX_PIN	= D11
-)
-```
-
-UART1 pins
-
-
-```go
-const (
-	SDA_PIN	= PA22	// SDA: SERCOM3/PAD[0]
-	SCL_PIN	= PA23	// SCL: SERCOM3/PAD[1]
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	= PB11	// SCK: SERCOM4/PAD[3]
-	SPI0_SDO_PIN	= PB10	// SDO: SERCOM4/PAD[2]
-	SPI0_SDI_PIN	= PA12	// SDI: SERCOM4/PAD[0]
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	I2S_SCK_PIN	= PA10
-	I2S_SD_PIN	= PA08
-	I2S_WS_PIN	= NoPin	// TODO: figure out what this is on Feather M0.
-)
-```
-
-I2S pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const (
-	I2SModeSource	I2SMode	= iota
-	I2SModeReceiver
-	I2SModePDM
-)
-```
-
-
-
-```go
-const (
-	I2StandardPhilips	I2SStandard	= iota
-	I2SStandardMSB
-	I2SStandardLSB
-)
-```
-
-
-
-```go
-const (
-	I2SClockSourceInternal	I2SClockSource	= iota
-	I2SClockSourceExternal
-)
-```
-
-
-
-```go
-const (
-	I2SDataFormatDefault	I2SDataFormat	= 0
-	I2SDataFormat8bit			= 8
-	I2SDataFormat16bit			= 16
-	I2SDataFormat24bit			= 24
-	I2SDataFormat32bit			= 32
-)
-```
-
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinAnalog	PinMode	= 1
-	PinSERCOM	PinMode	= 2
-	PinSERCOMAlt	PinMode	= 3
-	PinTimer	PinMode	= 4
-	PinTimerAlt	PinMode	= 5
-	PinCom		PinMode	= 6
-	//PinAC_CLK        PinMode = 7
-	PinDigital		PinMode	= 8
-	PinInput		PinMode	= 9
-	PinInputPullup		PinMode	= 10
-	PinOutput		PinMode	= 11
-	PinPWM			PinMode	= PinTimer
-	PinPWMAlt		PinMode	= PinTimerAlt
-	PinInputPulldown	PinMode	= 12
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
-	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
-	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	Mode0	= 0
-	Mode1	= 1
-	Mode2	= 2
-	Mode3	= 3
-)
-```
-
-SPI phase and polarity configs CPOL and CPHA
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART1 = UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	sam.SERCOM1_USART,
-		SERCOM:	1,
-	}
-)
-```
-
-UART1 on the Feather M0.
-
-
-```go
-var (
-	I2C0 = I2C{
-		Bus:	sam.SERCOM3_I2CM,
-		SERCOM:	3,
-	}
-)
-```
-
-I2C on the Feather M0.
-
-
-```go
-var (
-	SPI0 = SPI{
-		Bus:	sam.SERCOM4_SPI,
-		SERCOM:	4,
-	}
-)
-```
-
-SPI on the Feather M0.
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	// UART0 is actually a USB CDC interface.
-	UART0 = USBCDC{Buffer: NewRingBuffer()}
-)
-```
-
-
-
-```go
-var (
-	DAC0 = DAC{}
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-Return the current CPU frequency in hertz.
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the PWM interface.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-### func ResetProcessor
-
-```go
-func ResetProcessor()
-```
-
-ResetProcessor should perform a system reset in preperation
-to switch to the bootloader to flash new firmware.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure()
-```
-
-Configure configures a ADCPin to be able to be used to read data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin, in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DAC
-
-```go
-type DAC struct {
-}
-```
-
-DAC on the SAMD21.
-
-
-
-### func (DAC) Configure
-
-```go
-func (dac DAC) Configure(config DACConfig)
-```
-
-Configure the DAC.
-output pin must already be configured.
-
-
-### func (DAC) Set
-
-```go
-func (dac DAC) Set(value uint16) error
-```
-
-Set writes a single 16-bit value to the DAC.
-Since the ATSAMD21 only has a 10-bit DAC, the passed-in value will be scaled down.
-
-
-
-
-## type DACConfig
-
-```go
-type DACConfig struct {
-}
-```
-
-DACConfig placeholder for future expansion.
-
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus	*sam.SERCOM_I2CM_Type
-	SERCOM	uint8
-}
-```
-
-I2C on the SAMD21.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig) error
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) SetBaudRate
-
-```go
-func (i2c I2C) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the I2C.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteByte
-
-```go
-func (i2c I2C) WriteByte(data byte) error
-```
-
-WriteByte writes a single byte to the I2C bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type I2S
-
-```go
-type I2S struct {
-	Bus *sam.I2S_Type
-}
-```
-
-I2S
-
-
-
-### func (I2S) Close
-
-```go
-func (i2s I2S) Close() error
-```
-
-Close the I2S bus.
-
-
-### func (I2S) Configure
-
-```go
-func (i2s I2S) Configure(config I2SConfig)
-```
-
-Configure is used to configure the I2S interface. You must call this
-before you can use the I2S bus.
-
-
-### func (I2S) Read
-
-```go
-func (i2s I2S) Read(p []uint32) (n int, err error)
-```
-
-Read data from the I2S bus into the provided slice.
-The I2S bus must already have been configured correctly.
-
-
-### func (I2S) Write
-
-```go
-func (i2s I2S) Write(p []uint32) (n int, err error)
-```
-
-Write data to the I2S bus from the provided slice.
-The I2S bus must already have been configured correctly.
-
-
-
-
-## type I2SClockSource
-
-```go
-type I2SClockSource uint8
-```
-
-
-
-
-
-
-## type I2SConfig
-
-```go
-type I2SConfig struct {
-	SCK		Pin
-	WS		Pin
-	SD		Pin
-	Mode		I2SMode
-	Standard	I2SStandard
-	ClockSource	I2SClockSource
-	DataFormat	I2SDataFormat
-	AudioFrequency	uint32
-	MainClockOutput	bool
-	Stereo		bool
-}
-```
-
-All fields are optional and may not be required or used on a particular platform.
-
-
-
-
-
-## type I2SDataFormat
-
-```go
-type I2SDataFormat uint8
-```
-
-
-
-
-
-
-## type I2SMode
-
-```go
-type I2SMode uint8
-```
-
-
-
-
-
-
-## type I2SStandard
-
-```go
-type I2SStandard uint8
-```
-
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure() error
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus	*sam.SERCOM_SPI_Type
-	SERCOM	uint8
-}
-```
-
-SPI
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig) error
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer		*RingBuffer
-	Bus		*sam.SERCOM_USART_Type
-	SERCOM		uint8
-	Interrupt	interrupt.Interrupt
-}
-```
-
-UART on the SAMD21.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig) error
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer *RingBuffer
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the SAMD21.
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (USBCDC) Configure
-
-```go
-func (usbcdc USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/feather-m4.md b/content/microcontrollers/machine/feather-m4.md
deleted file mode 100644
index 0c25df5d..00000000
--- a/content/microcontrollers/machine/feather-m4.md
+++ /dev/null
@@ -1,1681 +0,0 @@
-
----
-title: feather-m4
----
-
-
-## Constants
-
-```go
-const RESET_MAGIC_VALUE = 0xf01669ef
-```
-
-used to reset into bootloader
-
-
-```go
-const (
-	D0	= PB17	// UART0 RX/PWM available
-	D1	= PB16	// UART0 TX/PWM available
-	D4	= PA14	// PWM available
-	D5	= PA16	// PWM available
-	D6	= PA18	// PWM available
-	D8	= PB03	// built-in neopixel
-	D9	= PA19	// PWM available
-	D10	= PA20	// can be used for PWM or UART1 TX
-	D11	= PA21	// can be used for PWM or UART1 RX
-	D12	= PA22	// PWM available
-	D13	= PA23	// PWM available
-	D21	= PA13	// PWM available
-	D22	= PA12	// PWM available
-	D23	= PB22	// PWM available
-	D24	= PB23	// PWM available
-	D25	= PA17	// PWM available
-)
-```
-
-GPIO Pins
-
-
-```go
-const (
-	A0	= PA02	// ADC/AIN[0]
-	A1	= PA05	// ADC/AIN[2]
-	A2	= PB08	// ADC/AIN[3]
-	A3	= PB09	// ADC/AIN[4]
-	A4	= PA04	// ADC/AIN[5]
-	A5	= PA06	// ADC/AIN[10]
-)
-```
-
-Analog pins
-
-
-```go
-const (
-	LED = D13
-)
-```
-
-
-
-```go
-const (
-	USBCDC_DM_PIN	= PA24
-	USBCDC_DP_PIN	= PA25
-)
-```
-
-UART0 aka USBCDC pins
-
-
-```go
-const (
-	UART_TX_PIN	= D1
-	UART_RX_PIN	= D0
-)
-```
-
-
-
-```go
-const (
-	UART2_TX_PIN	= A4
-	UART2_RX_PIN	= A5
-)
-```
-
-
-
-```go
-const (
-	SDA_PIN	= D22	// SDA: SERCOM2/PAD[0]
-	SCL_PIN	= D21	// SCL: SERCOM2/PAD[1]
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	= D25	// SCK: SERCOM1/PAD[1]
-	SPI0_SDO_PIN	= D24	// SDO: SERCOM1/PAD[3]
-	SPI0_SDI_PIN	= D23	// SDI: SERCOM1/PAD[2]
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const (
-	I2SModeSource	I2SMode	= iota
-	I2SModeReceiver
-	I2SModePDM
-)
-```
-
-
-
-```go
-const (
-	I2StandardPhilips	I2SStandard	= iota
-	I2SStandardMSB
-	I2SStandardLSB
-)
-```
-
-
-
-```go
-const (
-	I2SClockSourceInternal	I2SClockSource	= iota
-	I2SClockSourceExternal
-)
-```
-
-
-
-```go
-const (
-	I2SDataFormatDefault	I2SDataFormat	= 0
-	I2SDataFormat8bit			= 8
-	I2SDataFormat16bit			= 16
-	I2SDataFormat24bit			= 24
-	I2SDataFormat32bit			= 32
-)
-```
-
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinAnalog		PinMode	= 1
-	PinSERCOM		PinMode	= 2
-	PinSERCOMAlt		PinMode	= 3
-	PinTimer		PinMode	= 4
-	PinTimerAlt		PinMode	= 5
-	PinTCCPDEC		PinMode	= 6
-	PinCom			PinMode	= 7
-	PinSDHC			PinMode	= 8
-	PinI2S			PinMode	= 9
-	PinPCC			PinMode	= 10
-	PinGMAC			PinMode	= 11
-	PinACCLK		PinMode	= 12
-	PinCCL			PinMode	= 13
-	PinDigital		PinMode	= 14
-	PinInput		PinMode	= 15
-	PinInputPullup		PinMode	= 16
-	PinOutput		PinMode	= 17
-	PinPWME			PinMode	= PinTimer
-	PinPWMF			PinMode	= PinTimerAlt
-	PinPWMG			PinMode	= PinTCCPDEC
-	PinInputPulldown	PinMode	= 18
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
-	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
-	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	PA00	Pin	= 0
-	PA01	Pin	= 1
-	PA02	Pin	= 2
-	PA03	Pin	= 3
-	PA04	Pin	= 4
-	PA05	Pin	= 5
-	PA06	Pin	= 6
-	PA07	Pin	= 7
-	PA08	Pin	= 8
-	PA09	Pin	= 9
-	PA10	Pin	= 10
-	PA11	Pin	= 11
-	PA12	Pin	= 12
-	PA13	Pin	= 13
-	PA14	Pin	= 14
-	PA15	Pin	= 15
-	PA16	Pin	= 16
-	PA17	Pin	= 17
-	PA18	Pin	= 18
-	PA19	Pin	= 19
-	PA20	Pin	= 20
-	PA21	Pin	= 21
-	PA22	Pin	= 22
-	PA23	Pin	= 23
-	PA24	Pin	= 24
-	PA25	Pin	= 25
-	PA26	Pin	= 26
-	PA27	Pin	= 27
-	PA28	Pin	= 28
-	PA29	Pin	= 29
-	PA30	Pin	= 30
-	PA31	Pin	= 31
-	PB00	Pin	= 32
-	PB01	Pin	= 33
-	PB02	Pin	= 34
-	PB03	Pin	= 35
-	PB04	Pin	= 36
-	PB05	Pin	= 37
-	PB06	Pin	= 38
-	PB07	Pin	= 39
-	PB08	Pin	= 40
-	PB09	Pin	= 41
-	PB10	Pin	= 42
-	PB11	Pin	= 43
-	PB12	Pin	= 44
-	PB13	Pin	= 45
-	PB14	Pin	= 46
-	PB15	Pin	= 47
-	PB16	Pin	= 48
-	PB17	Pin	= 49
-	PB18	Pin	= 50
-	PB19	Pin	= 51
-	PB20	Pin	= 52
-	PB21	Pin	= 53
-	PB22	Pin	= 54
-	PB23	Pin	= 55
-	PB24	Pin	= 56
-	PB25	Pin	= 57
-	PB26	Pin	= 58
-	PB27	Pin	= 59
-	PB28	Pin	= 60
-	PB29	Pin	= 61
-	PB30	Pin	= 62
-	PB31	Pin	= 63
-	PC00	Pin	= 64
-	PC01	Pin	= 65
-	PC02	Pin	= 66
-	PC03	Pin	= 67
-	PC04	Pin	= 68
-	PC05	Pin	= 69
-	PC06	Pin	= 70
-	PC07	Pin	= 71
-	PC08	Pin	= 72
-	PC09	Pin	= 73
-	PC10	Pin	= 74
-	PC11	Pin	= 75
-	PC12	Pin	= 76
-	PC13	Pin	= 77
-	PC14	Pin	= 78
-	PC15	Pin	= 79
-	PC16	Pin	= 80
-	PC17	Pin	= 81
-	PC18	Pin	= 82
-	PC19	Pin	= 83
-	PC20	Pin	= 84
-	PC21	Pin	= 85
-	PC22	Pin	= 86
-	PC23	Pin	= 87
-	PC24	Pin	= 88
-	PC25	Pin	= 89
-	PC26	Pin	= 90
-	PC27	Pin	= 91
-	PC28	Pin	= 92
-	PC29	Pin	= 93
-	PC30	Pin	= 94
-	PC31	Pin	= 95
-	PD00	Pin	= 96
-	PD01	Pin	= 97
-	PD02	Pin	= 98
-	PD03	Pin	= 99
-	PD04	Pin	= 100
-	PD05	Pin	= 101
-	PD06	Pin	= 102
-	PD07	Pin	= 103
-	PD08	Pin	= 104
-	PD09	Pin	= 105
-	PD10	Pin	= 106
-	PD11	Pin	= 107
-	PD12	Pin	= 108
-	PD13	Pin	= 109
-	PD14	Pin	= 110
-	PD15	Pin	= 111
-	PD16	Pin	= 112
-	PD17	Pin	= 113
-	PD18	Pin	= 114
-	PD19	Pin	= 115
-	PD20	Pin	= 116
-	PD21	Pin	= 117
-	PD22	Pin	= 118
-	PD23	Pin	= 119
-	PD24	Pin	= 120
-	PD25	Pin	= 121
-	PD26	Pin	= 122
-	PD27	Pin	= 123
-	PD28	Pin	= 124
-	PD29	Pin	= 125
-	PD30	Pin	= 126
-	PD31	Pin	= 127
-)
-```
-
-Hardware pins
-
-
-```go
-const (
-	// SERCOM_FREQ_REF is always reference frequency on SAMD51 regardless of CPU speed.
-	SERCOM_FREQ_REF	= 48000000
-
-	// Default rise time in nanoseconds, based on 4.7K ohm pull up resistors
-	riseTimeNanoseconds	= 125
-
-	// wire bus states
-	wireUnknownState	= 0
-	wireIdleState		= 1
-	wireOwnerState		= 2
-	wireBusyState		= 3
-
-	// wire commands
-	wireCmdNoAction		= 0
-	wireCmdRepeatStart	= 1
-	wireCmdRead		= 2
-	wireCmdStop		= 3
-)
-```
-
-
-
-```go
-const (
-	QSPI_SCK	= PB10
-	QSPI_CS		= PB11
-	QSPI_DATA0	= PA08
-	QSPI_DATA1	= PA09
-	QSPI_DATA2	= PA10
-	QSPI_DATA3	= PA11
-)
-```
-
-The QSPI peripheral on ATSAMD51 is only available on the following pins
-
-
-```go
-const HSRAM_SIZE = 0x00030000
-```
-
-
-
-```go
-const (
-	Mode0	= 0
-	Mode1	= 1
-	Mode2	= 2
-	Mode3	= 3
-)
-```
-
-SPI phase and polarity configs CPOL and CPHA
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART1	= UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	sam.SERCOM5_USART_INT,
-		SERCOM:	5,
-	}
-
-	UART2	= UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	sam.SERCOM0_USART_INT,
-		SERCOM:	0,
-	}
-)
-```
-
-
-
-```go
-var (
-	I2C0 = I2C{
-		Bus:	sam.SERCOM2_I2CM,
-		SERCOM:	2,
-	}
-)
-```
-
-I2C on the Feather M4.
-
-
-```go
-var (
-	SPI0 = SPI{
-		Bus:	sam.SERCOM1_SPIM,
-		SERCOM:	1,
-	}
-)
-```
-
-SPI on the Feather M4.
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	// UART0 is actually a USB CDC interface.
-	UART0 = USBCDC{Buffer: NewRingBuffer()}
-)
-```
-
-
-
-```go
-var (
-	DAC0 = DAC{}
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the PWM interface.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-### func ResetProcessor
-
-```go
-func ResetProcessor()
-```
-
-ResetProcessor should perform a system reset in preparation
-to switch to the bootloader to flash new firmware.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure()
-```
-
-Configure configures a ADCPin to be able to be used to read data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin, in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DAC
-
-```go
-type DAC struct {
-}
-```
-
-DAC on the SAMD51.
-
-
-
-### func (DAC) Configure
-
-```go
-func (dac DAC) Configure(config DACConfig)
-```
-
-Configure the DAC.
-output pin must already be configured.
-
-
-### func (DAC) Set
-
-```go
-func (dac DAC) Set(value uint16) error
-```
-
-Set writes a single 16-bit value to the DAC.
-Since the ATSAMD51 only has a 12-bit DAC, the passed-in value will be scaled down.
-
-
-
-
-## type DACConfig
-
-```go
-type DACConfig struct {
-}
-```
-
-DACConfig placeholder for future expansion.
-
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus	*sam.SERCOM_I2CM_Type
-	SERCOM	uint8
-}
-```
-
-I2C on the SAMD51.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig) error
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) SetBaudRate
-
-```go
-func (i2c I2C) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the I2C.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteByte
-
-```go
-func (i2c I2C) WriteByte(data byte) error
-```
-
-WriteByte writes a single byte to the I2C bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type I2SClockSource
-
-```go
-type I2SClockSource uint8
-```
-
-
-
-
-
-
-## type I2SConfig
-
-```go
-type I2SConfig struct {
-	SCK		Pin
-	WS		Pin
-	SD		Pin
-	Mode		I2SMode
-	Standard	I2SStandard
-	ClockSource	I2SClockSource
-	DataFormat	I2SDataFormat
-	AudioFrequency	uint32
-	MainClockOutput	bool
-	Stereo		bool
-}
-```
-
-All fields are optional and may not be required or used on a particular platform.
-
-
-
-
-
-## type I2SDataFormat
-
-```go
-type I2SDataFormat uint8
-```
-
-
-
-
-
-
-## type I2SMode
-
-```go
-type I2SMode uint8
-```
-
-
-
-
-
-
-## type I2SStandard
-
-```go
-type I2SStandard uint8
-```
-
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure() error
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-### func (Pin) Toggle
-
-```go
-func (p Pin) Toggle()
-```
-
-Toggle switches an output pin from low to high or from high to low.
-Warning: only use this on an output pin!
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus	*sam.SERCOM_SPIM_Type
-	SERCOM	uint8
-}
-```
-
-SPI
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig) error
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer		*RingBuffer
-	Bus		*sam.SERCOM_USART_INT_Type
-	SERCOM		uint8
-	Interrupt	interrupt.Interrupt	// RXC interrupt
-}
-```
-
-UART on the SAMD51.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig) error
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer *RingBuffer
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the SAMD21.
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (USBCDC) Configure
-
-```go
-func (usbcdc USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/feather-nrf52840.md b/content/microcontrollers/machine/feather-nrf52840.md
deleted file mode 100644
index 1d1995d8..00000000
--- a/content/microcontrollers/machine/feather-nrf52840.md
+++ /dev/null
@@ -1,1396 +0,0 @@
-
----
-title: feather-nrf52840
----
-
-
-## Constants
-
-```go
-const HasLowFrequencyCrystal = true
-```
-
-
-
-```go
-const (
-	D0	= P0_25	// UART TX
-	D1	= P0_24	// UART RX
-	D2	= P0_10	// NFC2
-	D3	= P1_15	// LED1
-	D4	= P1_10	// LED2
-	D5	= P1_08
-	D6	= P0_07
-	D7	= P1_02	// Button
-	D8	= P0_16	// NeoPixel
-	D9	= P0_26
-	D10	= P0_27
-	D11	= P0_06
-	D12	= P0_08
-	D13	= P1_09
-	D14	= P0_04	// A0
-	D15	= P0_05	// A1
-	D16	= P0_30	// A2
-	D17	= P0_28	// A3
-	D18	= P0_02	// A4
-	D19	= P0_03	// A5
-	D20	= P0_29	// Battery
-	D21	= P0_31	// AREF
-	D22	= P0_12	// I2C SDA
-	D23	= P0_11	// I2C SCL
-	D24	= P0_15	// SPI MISO
-	D25	= P0_13	// SPI MOSI
-	D26	= P0_14	// SPI SCK
-	D27	= P0_19	// QSPI CLK
-	D28	= P0_20	// QSPI CS
-	D29	= P0_17	// QSPI Data 0
-	D30	= P0_22	// QSPI Data 1
-	D31	= P0_23	// QSPI Data 2
-	D32	= P0_21	// QSPI Data 3
-	D33	= P0_09	// NFC1 (test point on bottom of board)
-)
-```
-
-GPIO Pins
-
-
-```go
-const (
-	A0	= D14
-	A1	= D15
-	A2	= D16
-	A3	= D17
-	A4	= D18
-	A5	= D19
-	A6	= D20	// Battery
-	A7	= D21	// ARef
-)
-```
-
-Analog Pins
-
-
-```go
-const (
-	LED		= D3
-	LED1		= LED
-	LED2		= D4
-	NEOPIXEL	= D8
-	BUTTON		= D7
-
-	QSPI_SCK	= D27
-	QSPI_CS		= D28
-	QSPI_DATA0	= D29
-	QSPI_DATA1	= D30
-	QSPI_DATA2	= D31
-	QSPI_DATA3	= D32
-)
-```
-
-
-
-```go
-const (
-	UART_RX_PIN	= D0
-	UART_TX_PIN	= D1
-)
-```
-
-UART0 pins (logical UART1)
-
-
-```go
-const (
-	SDA_PIN	= D22	// I2C0 external
-	SCL_PIN	= D23	// I2C0 external
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	= D26	// SCK
-	SPI0_SDO_PIN	= D25	// SDO
-	SPI0_SDI_PIN	= D24	// SDI
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Disconnect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
-	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
-	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	P0_00	Pin	= 0
-	P0_01	Pin	= 1
-	P0_02	Pin	= 2
-	P0_03	Pin	= 3
-	P0_04	Pin	= 4
-	P0_05	Pin	= 5
-	P0_06	Pin	= 6
-	P0_07	Pin	= 7
-	P0_08	Pin	= 8
-	P0_09	Pin	= 9
-	P0_10	Pin	= 10
-	P0_11	Pin	= 11
-	P0_12	Pin	= 12
-	P0_13	Pin	= 13
-	P0_14	Pin	= 14
-	P0_15	Pin	= 15
-	P0_16	Pin	= 16
-	P0_17	Pin	= 17
-	P0_18	Pin	= 18
-	P0_19	Pin	= 19
-	P0_20	Pin	= 20
-	P0_21	Pin	= 21
-	P0_22	Pin	= 22
-	P0_23	Pin	= 23
-	P0_24	Pin	= 24
-	P0_25	Pin	= 25
-	P0_26	Pin	= 26
-	P0_27	Pin	= 27
-	P0_28	Pin	= 28
-	P0_29	Pin	= 29
-	P0_30	Pin	= 30
-	P0_31	Pin	= 31
-	P1_00	Pin	= 32
-	P1_01	Pin	= 33
-	P1_02	Pin	= 34
-	P1_03	Pin	= 35
-	P1_04	Pin	= 36
-	P1_05	Pin	= 37
-	P1_06	Pin	= 38
-	P1_07	Pin	= 39
-	P1_08	Pin	= 40
-	P1_09	Pin	= 41
-	P1_10	Pin	= 42
-	P1_11	Pin	= 43
-	P1_12	Pin	= 44
-	P1_13	Pin	= 45
-	P1_14	Pin	= 46
-	P1_15	Pin	= 47
-)
-```
-
-Hardware pins
-
-
-```go
-const (
-	DFU_MAGIC_SERIAL_ONLY_RESET	= 0x4e
-	DFU_MAGIC_UF2_RESET		= 0x57
-	DFU_MAGIC_OTA_RESET		= 0xA8
-)
-```
-
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART0 = USB
-)
-```
-
-UART0 is the USB device
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-```go
-var (
-	// NRF_UART0 is the hardware UART on the NRF SoC.
-	NRF_UART0 = UART{Buffer: NewRingBuffer()}
-)
-```
-
-UART
-
-
-```go
-var (
-	I2C0	= I2C{Bus: nrf.TWI0}
-	I2C1	= I2C{Bus: nrf.TWI1}
-)
-```
-
-There are 2 I2C interfaces on the NRF.
-
-
-```go
-var (
-	SPI0	= SPI{Bus: nrf.SPI0}
-	SPI1	= SPI{Bus: nrf.SPI1}
-)
-```
-
-There are 2 SPI interfaces on the NRF5x.
-
-
-```go
-var (
-	USB	= USBCDC{Buffer: NewRingBuffer()}
-
-	usbEndpointDescriptors	[8]usbDeviceDescriptor
-
-	udd_ep_in_cache_buffer	[7][128]uint8
-	udd_ep_out_cache_buffer	[7][128]uint8
-
-	sendOnEP0DATADONE	struct {
-		ptr	*byte
-		count	int
-	}
-	isEndpointHalt		= false
-	isRemoteWakeUpEnabled	= false
-	endPoints		= []uint32{usb_ENDPOINT_TYPE_CONTROL,
-		(usb_ENDPOINT_TYPE_INTERRUPT | usbEndpointIn),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointOut),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointIn)}
-
-	usbConfiguration		uint8
-	usbSetInterface			uint8
-	usbLineInfo			= cdcLineInfo{115200, 0x00, 0x00, 0x08, 0x00}
-	epinen				uint32
-	epouten				uint32
-	easyDMABusy			volatile.Register8
-	epout0data_setlinecoding	bool
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func EnterOTABootloader
-
-```go
-func EnterOTABootloader()
-```
-
-EnterOTABootloader resets the chip into the bootloader so that it can be
-flashed via an OTA update
-
-
-### func EnterSerialBootloader
-
-```go
-func EnterSerialBootloader()
-```
-
-EnterSerialBootloader resets the chip into the serial bootloader. After
-reset, it can be flashed using serial/nrfutil.
-
-
-### func EnterUF2Bootloader
-
-```go
-func EnterUF2Bootloader()
-```
-
-EnterUF2Bootloader resets the chip into the UF2 bootloader. After reset, it
-can be flashed via nrfutil or by copying a UF2 file to the mass storage device
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the registers needed for ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the registers needed for PWM.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure() error
-```
-
-Configure configures an ADC pin to be able to read analog data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus *nrf.TWI_Type
-}
-```
-
-I2C on the NRF.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) (err error)
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure()
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *nrf.SPI_Type
-}
-```
-
-SPI on the NRF.
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the NRF.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer		*RingBuffer
-	interrupt	interrupt.Interrupt
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the nRF52840
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (*USBCDC) Configure
-
-```go
-func (usbcdc *USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/feather-stm32f405.md b/content/microcontrollers/machine/feather-stm32f405.md
deleted file mode 100644
index ae463606..00000000
--- a/content/microcontrollers/machine/feather-stm32f405.md
+++ /dev/null
@@ -1,914 +0,0 @@
-
----
-title: feather-stm32f405
----
-
-
-## Constants
-
-```go
-const (
-	NUM_DIGITAL_IO_PINS	= 39
-	NUM_ANALOG_IO_PINS	= 7
-)
-```
-
-
-
-```go
-const (
-	// Arduino pin = MCU port pin // primary functions (alternate functions)
-	D0	= PB11	// USART3 RX, PWM TIM2_CH4 (I2C2 SDA)
-	D1	= PB10	// USART3 TX, PWM TIM2_CH3 (I2C2 SCL, I2S2 BCK)
-	D2	= PB3	// GPIO, SPI3 FLASH SCK
-	D3	= PB4	// GPIO, SPI3 FLASH MISO
-	D4	= PB5	// GPIO, SPI3 FLASH MOSI
-	D5	= PC7	// GPIO, PWM TIM3_CH2 (USART6 RX, I2S3 MCK)
-	D6	= PC6	// GPIO, PWM TIM3_CH1 (USART6 TX, I2S2 MCK)
-	D7	= PA15	// GPIO, SPI3 FLASH CS
-	D8	= PC0	// GPIO, Neopixel
-	D9	= PB8	// GPIO, PWM TIM4_CH3 (CAN1 RX, I2C1 SCL)
-	D10	= PB9	// GPIO, PWM TIM4_CH4 (CAN1 TX, I2C1 SDA, I2S2 WSL)
-	D11	= PC3	// GPIO (I2S2 SD, SPI2 MOSI)
-	D12	= PC2	// GPIO (I2S2ext SD, SPI2 MISO)
-	D13	= PC1	// GPIO, Builtin LED
-	D14	= PB7	// I2C1 SDA, PWM TIM4_CH2 (USART1 RX)
-	D15	= PB6	// I2C1 SCL, PWM TIM4_CH1 (USART1 TX, CAN2 TX)
-	D16	= PA4	// A0 (DAC OUT1)
-	D17	= PA5	// A1 (DAC OUT2, SPI1 SCK)
-	D18	= PA6	// A2, PWM TIM3_CH1 (SPI1 MISO)
-	D19	= PA7	// A3, PWM TIM3_CH2 (SPI1 MOSI)
-	D20	= PC4	// A4
-	D21	= PC5	// A5
-	D22	= PA3	// A6
-	D23	= PB13	// SPI2 SCK, PWM TIM1_CH1N (I2S2 BCK, CAN2 TX)
-	D24	= PB14	// SPI2 MISO, PWM TIM1_CH2N (I2S2ext SD)
-	D25	= PB15	// SPI2 MOSI, PWM TIM1_CH3N (I2S2 SD)
-	D26	= PC8	// SDIO
-	D27	= PC9	// SDIO
-	D28	= PC10	// SDIO
-	D29	= PC11	// SDIO
-	D30	= PC12	// SDIO
-	D31	= PD2	// SDIO
-	D32	= PB12	// SD Detect
-	D33	= PC14	// OSC32
-	D34	= PC15	// OSC32
-	D35	= PA11	// USB D+
-	D36	= PA12	// USB D-
-	D37	= PA13	// SWDIO
-	D38	= PA14	// SWCLK
-)
-```
-
-Digital pins
-
-
-```go
-const (
-	A0	= D16	// ADC12 IN4
-	A1	= D17	// ADC12 IN5
-	A2	= D18	// ADC12 IN6
-	A3	= D19	// ADC12 IN7
-	A4	= D20	// ADC12 IN14
-	A5	= D21	// ADC12 IN15
-	A6	= D22	// VBAT
-)
-```
-
-Analog pins
-
-
-```go
-const (
-	NUM_BOARD_LED		= 1
-	NUM_BOARD_NEOPIXEL	= 1
-
-	LED_RED		= D13
-	LED_NEOPIXEL	= D8
-	LED_BUILTIN	= LED_RED
-	LED		= LED_BUILTIN
-)
-```
-
-
-
-```go
-const (
-	// #===========#==========#==============#============#=======#=======#
-	// | Interface | Hardware |  Bus(Freq)   | RX/TX Pins | AltFn | Alias |
-	// #===========#==========#==============#============#=======#=======#
-	// |   UART1   |  USART3  | APB1(42 MHz) |   D0/D1    |   7   |   ~   |
-	// |   UART2   |  USART6  | APB2(84 MHz) |   D5/D6    |   8   |   ~   |
-	// |   UART3   |  USART1  | APB2(84 MHz) |  D14/D15   |   7   |   ~   |
-	// | --------- | -------- | ------------ | ---------- | ----- | ----- |
-	// |   UART0   |  USART3  | APB1(42 MHz) |   D0/D1    |   7   | UART1 |
-	// #===========#==========#==============#============#=======#=======#
-	NUM_UART_INTERFACES	= 3
-
-	UART1_RX_PIN	= D0	// UART1 = hardware: USART3
-	UART1_TX_PIN	= D1	//
-
-	UART2_RX_PIN	= D5	// UART2 = hardware: USART6
-	UART2_TX_PIN	= D6	//
-
-	UART3_RX_PIN	= D14	// UART3 = hardware: USART1
-	UART3_TX_PIN	= D15	//
-
-	UART0_RX_PIN	= UART1_RX_PIN	// UART0 = alias: UART1
-	UART0_TX_PIN	= UART1_TX_PIN	//
-
-	UART_RX_PIN	= UART0_RX_PIN	// default/primary UART pins
-	UART_TX_PIN	= UART0_TX_PIN	//
-)
-```
-
-
-
-```go
-const (
-	// #===========#==========#==============#==================#=======#=======#
-	// | Interface | Hardware |  Bus(Freq)   | SCK/SDI/SDO Pins | AltFn | Alias |
-	// #===========#==========#==============#==================#=======#=======#
-	// |   SPI1    |   SPI2   | APB1(42 MHz) |    D23/D24/D25   |   5   |   ~   |
-	// |   SPI2    |   SPI3   | APB1(42 MHz) |     D2/D3/D4     |   6   |   ~   |
-	// |   SPI3    |   SPI1   | APB2(84 MHz) |    D17/D18/D19   |   5   |   ~   |
-	// | --------- | -------- | ------------ | ---------------- | ----- | ----- |
-	// |   SPI0    |   SPI2   | APB1(42 MHz) |    D23/D24/D25   |   5   | SPI1  |
-	// #===========#==========#==============#==================#=======#=======#
-	NUM_SPI_INTERFACES	= 3
-
-	SPI1_SCK_PIN	= D23	//
-	SPI1_SDI_PIN	= D24	// SPI1 = hardware: SPI2
-	SPI1_SDO_PIN	= D25	//
-
-	SPI2_SCK_PIN	= D2	//
-	SPI2_SDI_PIN	= D3	// SPI2 = hardware: SPI3
-	SPI2_SDO_PIN	= D4	//
-
-	SPI3_SCK_PIN	= D17	//
-	SPI3_SDI_PIN	= D18	// SPI3 = hardware: SPI1
-	SPI3_SDO_PIN	= D19	//
-
-	SPI0_SCK_PIN	= SPI1_SCK_PIN	//
-	SPI0_SDI_PIN	= SPI1_SDI_PIN	// SPI0 = alias: SPI1
-	SPI0_SDO_PIN	= SPI1_SDO_PIN	//
-
-	SPI_SCK_PIN	= SPI0_SCK_PIN	//
-	SPI_SDI_PIN	= SPI0_SDI_PIN	// default/primary SPI pins
-	SPI_SDO_PIN	= SPI0_SDO_PIN	//
-)
-```
-
-
-
-```go
-const (
-	// #===========#==========#==============#==============#=======#=======#
-	// | Interface | Hardware |  Bus(Freq)   | SDA/SCL Pins | AltFn | Alias |
-	// #===========#==========#==============#==============#=======#=======#
-	// |   I2C1    |   I2C1   | APB1(42 MHz) |   D14/D15    |   4   |   ~   |
-	// |   I2C2    |   I2C2   | APB1(42 MHz) |    D0/D1     |   4   |   ~   |
-	// |   I2C3    |   I2C1   | APB1(42 MHz) |    D9/D10    |   4   |   ~   |
-	// | --------- | -------- | ------------ | ------------ | ----- | ----- |
-	// |   I2C0    |   I2C1   | APB1(42 MHz) |   D14/D15    |   4   | I2C1  |
-	// #===========#==========#==============#==============#=======#=======#
-	NUM_I2C_INTERFACES	= 3
-
-	I2C1_SDA_PIN	= D14	// I2C1 = hardware: I2C1
-	I2C1_SCL_PIN	= D15	//
-
-	I2C2_SDA_PIN	= D0	// I2C2 = hardware: I2C2
-	I2C2_SCL_PIN	= D1	//
-
-	I2C3_SDA_PIN	= D9	// I2C3 = hardware: I2C1
-	I2C3_SCL_PIN	= D10	//   (interface duplicated on second pair of pins)
-
-	I2C0_SDA_PIN	= I2C1_SDA_PIN	// I2C0 = alias: I2C1
-	I2C0_SCL_PIN	= I2C1_SCL_PIN	//
-
-	I2C_SDA_PIN	= I2C0_SDA_PIN	// default/primary I2C pins
-	I2C_SCL_PIN	= I2C0_SCL_PIN	//
-)
-```
-
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	DutyCycle2	= 0
-	DutyCycle16x9	= 1
-)
-```
-
-I2C fast mode (Fm) duty cycle
-
-
-```go
-const (
-	// Mode Flag
-	PinOutput		PinMode	= 0
-	PinInput		PinMode	= PinInputFloating
-	PinInputFloating	PinMode	= 1
-	PinInputPulldown	PinMode	= 2
-	PinInputPullup		PinMode	= 3
-
-	// for UART
-	PinModeUARTTX	PinMode	= 4
-	PinModeUARTRX	PinMode	= 5
-
-	// for I2C
-	PinModeI2CSCL	PinMode	= 6
-	PinModeI2CSDA	PinMode	= 7
-
-	// for SPI
-	PinModeSPICLK	PinMode	= 8
-	PinModeSPISDO	PinMode	= 9
-	PinModeSPISDI	PinMode	= 10
-
-	// for analog/ADC
-	PinInputAnalog	PinMode	= 11
-)
-```
-
-
-
-```go
-const (
-	PA0	= portA + 0
-	PA1	= portA + 1
-	PA2	= portA + 2
-	PA3	= portA + 3
-	PA4	= portA + 4
-	PA5	= portA + 5
-	PA6	= portA + 6
-	PA7	= portA + 7
-	PA8	= portA + 8
-	PA9	= portA + 9
-	PA10	= portA + 10
-	PA11	= portA + 11
-	PA12	= portA + 12
-	PA13	= portA + 13
-	PA14	= portA + 14
-	PA15	= portA + 15
-
-	PB0	= portB + 0
-	PB1	= portB + 1
-	PB2	= portB + 2
-	PB3	= portB + 3
-	PB4	= portB + 4
-	PB5	= portB + 5
-	PB6	= portB + 6
-	PB7	= portB + 7
-	PB8	= portB + 8
-	PB9	= portB + 9
-	PB10	= portB + 10
-	PB11	= portB + 11
-	PB12	= portB + 12
-	PB13	= portB + 13
-	PB14	= portB + 14
-	PB15	= portB + 15
-
-	PC0	= portC + 0
-	PC1	= portC + 1
-	PC2	= portC + 2
-	PC3	= portC + 3
-	PC4	= portC + 4
-	PC5	= portC + 5
-	PC6	= portC + 6
-	PC7	= portC + 7
-	PC8	= portC + 8
-	PC9	= portC + 9
-	PC10	= portC + 10
-	PC11	= portC + 11
-	PC12	= portC + 12
-	PC13	= portC + 13
-	PC14	= portC + 14
-	PC15	= portC + 15
-
-	PD0	= portD + 0
-	PD1	= portD + 1
-	PD2	= portD + 2
-	PD3	= portD + 3
-	PD4	= portD + 4
-	PD5	= portD + 5
-	PD6	= portD + 6
-	PD7	= portD + 7
-	PD8	= portD + 8
-	PD9	= portD + 9
-	PD10	= portD + 10
-	PD11	= portD + 11
-	PD12	= portD + 12
-	PD13	= portD + 13
-	PD14	= portD + 14
-	PD15	= portD + 15
-
-	PE0	= portE + 0
-	PE1	= portE + 1
-	PE2	= portE + 2
-	PE3	= portE + 3
-	PE4	= portE + 4
-	PE5	= portE + 5
-	PE6	= portE + 6
-	PE7	= portE + 7
-	PE8	= portE + 8
-	PE9	= portE + 9
-	PE10	= portE + 10
-	PE11	= portE + 11
-	PE12	= portE + 12
-	PE13	= portE + 13
-	PE14	= portE + 14
-	PE15	= portE + 15
-
-	PH0	= portH + 0
-	PH1	= portH + 1
-)
-```
-
-
-
-```go
-const (
-	Mode0	= 0
-	Mode1	= 1
-	Mode2	= 2
-	Mode3	= 3
-)
-```
-
-SPI phase and polarity configs CPOL and CPHA
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART1	= UART{
-		Buffer:			NewRingBuffer(),
-		Bus:			stm32.USART3,
-		AltFuncSelector:	stm32.AF7_USART1_2_3,
-	}
-	UART2	= UART{
-		Buffer:			NewRingBuffer(),
-		Bus:			stm32.USART6,
-		AltFuncSelector:	stm32.AF8_USART4_5_6,
-	}
-	UART3	= UART{
-		Buffer:			NewRingBuffer(),
-		Bus:			stm32.USART1,
-		AltFuncSelector:	stm32.AF7_USART1_2_3,
-	}
-	UART0	= UART1
-)
-```
-
-
-
-```go
-var (
-	SPI1	= SPI{
-		Bus:			stm32.SPI2,
-		AltFuncSelector:	stm32.AF5_SPI1_SPI2,
-	}
-	SPI2	= SPI{
-		Bus:			stm32.SPI3,
-		AltFuncSelector:	stm32.AF6_SPI3,
-	}
-	SPI3	= SPI{
-		Bus:			stm32.SPI1,
-		AltFuncSelector:	stm32.AF5_SPI1_SPI2,
-	}
-	SPI0	= SPI1
-)
-```
-
-
-
-```go
-var (
-	I2C1	= I2C{
-		Bus:			stm32.I2C1,
-		AltFuncSelector:	stm32.AF4_I2C1_2_3,
-	}
-	I2C2	= I2C{
-		Bus:			stm32.I2C2,
-		AltFuncSelector:	stm32.AF4_I2C1_2_3,
-	}
-	I2C3	= I2C{
-		Bus:			stm32.I2C1,
-		AltFuncSelector:	stm32.AF4_I2C1_2_3,
-	}
-	I2C0	= I2C1
-)
-```
-
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus		*stm32.I2C_Type
-	AltFuncSelector	stm32.AltFunc
-}
-```
-
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the STM32 I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-	DutyCycle	uint8
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration
-
-
-### func (Pin) ConfigureAltFunc
-
-```go
-func (p Pin) ConfigureAltFunc(config PinConfig, altFunc stm32.AltFunc)
-```
-
-Configure this pin with the given configuration including alternate
- function mapping if necessary.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetAltFunc
-
-```go
-func (p Pin) SetAltFunc(af stm32.AltFunc)
-```
-
-SetAltFunc maps the given alternative function to the I/O pin
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus		*stm32.SPI_Type
-	AltFuncSelector	stm32.AltFunc
-}
-```
-
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the STM32 SPI1 interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer		*RingBuffer
-	Bus		*stm32.USART_Type
-	Interrupt	interrupt.Interrupt
-	AltFuncSelector	stm32.AltFunc
-}
-```
-
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART. Defer to chip-specific
-routines for calculation
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/gameboy-advance.md b/content/microcontrollers/machine/gameboy-advance.md
deleted file mode 100644
index b44c3ea1..00000000
--- a/content/microcontrollers/machine/gameboy-advance.md
+++ /dev/null
@@ -1,271 +0,0 @@
-
----
-title: gameboy-advance
----
-
-
-## Constants
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	IRQ_VBLANK	= 0
-	IRQ_HBLANK	= 1
-	IRQ_VCOUNT	= 2
-	IRQ_TIMER0	= 3
-	IRQ_TIMER1	= 4
-	IRQ_TIMER2	= 5
-	IRQ_TIMER3	= 6
-	IRQ_COM		= 7
-	IRQ_DMA0	= 8
-	IRQ_DMA1	= 9
-	IRQ_DMA2	= 10
-	IRQ_DMA3	= 11
-	IRQ_KEYPAD	= 12
-	IRQ_GAMEPAK	= 13
-)
-```
-
-Interrupt numbers as used on the GameBoy Advance. Register them with
-runtime/interrupt.New.
-
-
-
-
-
-## Variables
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var Display = FramebufDisplay{(*[160][240]volatile.Register16)(unsafe.Pointer(uintptr(0x06000000)))}
-```
-
-
-
-
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type FramebufDisplay
-
-```go
-type FramebufDisplay struct {
-	port *[160][240]volatile.Register16
-}
-```
-
-
-
-
-### func (FramebufDisplay) Configure
-
-```go
-func (d FramebufDisplay) Configure()
-```
-
-
-
-### func (FramebufDisplay) Display
-
-```go
-func (d FramebufDisplay) Display() error
-```
-
-
-
-### func (FramebufDisplay) SetPixel
-
-```go
-func (d FramebufDisplay) SetPixel(x, y int16, c color.RGBA)
-```
-
-
-
-### func (FramebufDisplay) Size
-
-```go
-func (d FramebufDisplay) Size() (x, y int16)
-```
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(value bool)
-```
-
-Set has not been implemented.
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
diff --git a/content/microcontrollers/machine/hifive1-qemu.md b/content/microcontrollers/machine/hifive1-qemu.md
deleted file mode 100644
index e64f1575..00000000
--- a/content/microcontrollers/machine/hifive1-qemu.md
+++ /dev/null
@@ -1,657 +0,0 @@
-
----
-title: hifive1-qemu
----
-
-
-## Constants
-
-```go
-const (
-	P00	Pin	= 0
-	P01	Pin	= 1
-	P02	Pin	= 2
-	P03	Pin	= 3
-	P04	Pin	= 4
-	P05	Pin	= 5
-	P06	Pin	= 6
-	P07	Pin	= 7
-	P08	Pin	= 8
-	P09	Pin	= 9
-	P10	Pin	= 10
-	P11	Pin	= 11
-	P12	Pin	= 12
-	P13	Pin	= 13
-	P14	Pin	= 14
-	P15	Pin	= 15
-	P16	Pin	= 16
-	P17	Pin	= 17
-	P18	Pin	= 18
-	P19	Pin	= 19
-	P20	Pin	= 20
-	P21	Pin	= 21
-	P22	Pin	= 22
-	P23	Pin	= 23
-	P24	Pin	= 24
-	P25	Pin	= 25
-	P26	Pin	= 26
-	P27	Pin	= 27
-	P28	Pin	= 28
-	P29	Pin	= 29
-	P30	Pin	= 30
-	P31	Pin	= 31
-)
-```
-
-
-
-```go
-const (
-	D0	= P16
-	D1	= P17
-	D2	= P18
-	D3	= P19	// Green LED/PWM (PWM1_PWM1)
-	D4	= P20	// PWM (PWM1_PWM0)
-	D5	= P21	// Blue LED/PWM (PWM1_PWM2)
-	D6	= P22	// Red LED/PWM (PWM1_PWM3)
-	D7	= P16
-	D8	= NoPin	// PWM?
-	D9	= P01
-	D10	= P02	// SPI1_CS0
-	D11	= P03	// SPI1_DQ0
-	D12	= P04	// SPI1_DQ1
-	D13	= P05	// SPI1_SCK
-	D14	= NoPin	// not connected
-	D15	= P09	// does not seem to work?
-	D16	= P10	// PWM (PWM2_PWM0)
-	D17	= P11	// PWM (PWM2_PWM1)
-	D18	= P12	// SDA (I2C0_SDA)/PWM (PWM2_PWM2)
-	D19	= P13	// SDL (I2C0_SCL)/PWM (PWM2_PWM3)
-)
-```
-
-
-
-```go
-const (
-	LED		= LED1
-	LED1		= LED_RED
-	LED2		= LED_GREEN
-	LED3		= LED_BLUE
-	LED_RED		= P22
-	LED_GREEN	= P19
-	LED_BLUE	= P21
-)
-```
-
-
-
-```go
-const (
-	// TODO: figure out the pin numbers for these.
-	UART_TX_PIN	= D1
-	UART_RX_PIN	= D0
-)
-```
-
-
-
-```go
-const (
-	SPI0_SCK_PIN	= NoPin
-	SPI0_SDO_PIN	= NoPin
-	SPI0_SDI_PIN	= NoPin
-
-	SPI1_SCK_PIN	= D13
-	SPI1_SDO_PIN	= D11
-	SPI1_SDI_PIN	= D12
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	I2C0_SDA_PIN	= D18
-	I2C0_SCL_PIN	= D19
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput	PinMode	= iota
-	PinOutput
-	PinPWM
-	PinSPI
-	PinI2C	= PinSPI
-)
-```
-
-
-
-```go
-const (
-	Mode0	= 0
-	Mode1	= 1
-	Mode2	= 2
-	Mode3	= 3
-)
-```
-
-SPI phase and polarity configs CPOL and CPHA
-
-
-
-
-
-## Variables
-
-```go
-var (
-	SPI1 = SPI{
-		Bus: sifive.QSPI1,
-	}
-)
-```
-
-SPI on the HiFive1.
-
-
-```go
-var (
-	I2C0 = I2C{
-		Bus: sifive.I2C0,
-	}
-)
-```
-
-I2C on the HiFive1 rev B.
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	UART0 = UART{Bus: sifive.UART0, Buffer: NewRingBuffer()}
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus *sifive.I2C_Type
-}
-```
-
-I2C on the FE310-G002.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig) error
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *sifive.QSPI_Type
-}
-```
-
-SPI on the FE310. The normal SPI0 is actually a quad-SPI meant for flash, so it is best
-to use SPI1 or SPI2 port for most applications.
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig) error
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Bus	*sifive.UART_Type
-	Buffer	*RingBuffer
-}
-```
-
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte)
-```
-
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/itsybitsy-m0.md b/content/microcontrollers/machine/itsybitsy-m0.md
deleted file mode 100644
index 3b2d27bb..00000000
--- a/content/microcontrollers/machine/itsybitsy-m0.md
+++ /dev/null
@@ -1,1639 +0,0 @@
-
----
-title: itsybitsy-m0
----
-
-
-## Constants
-
-```go
-const (
-	PA00	Pin	= 0
-	PA01	Pin	= 1
-	PA02	Pin	= 2
-	PA03	Pin	= 3
-	PA04	Pin	= 4
-	PA05	Pin	= 5
-	PA06	Pin	= 6
-	PA07	Pin	= 7
-	PA08	Pin	= 8
-	PA09	Pin	= 9
-	PA10	Pin	= 10
-	PA11	Pin	= 11
-	PA12	Pin	= 12
-	PA13	Pin	= 13
-	PA14	Pin	= 14
-	PA15	Pin	= 15
-	PA16	Pin	= 16
-	PA17	Pin	= 17
-	PA18	Pin	= 18
-	PA19	Pin	= 19
-	PA20	Pin	= 20
-	PA21	Pin	= 21
-	PA22	Pin	= 22
-	PA23	Pin	= 23
-	PA24	Pin	= 24
-	PA25	Pin	= 25
-	PA26	Pin	= 26
-	PA27	Pin	= 27
-	PA28	Pin	= 28
-	PA29	Pin	= 29
-	PA30	Pin	= 30
-	PA31	Pin	= 31
-	PB00	Pin	= 32
-	PB01	Pin	= 33
-	PB02	Pin	= 34
-	PB03	Pin	= 35
-	PB04	Pin	= 36
-	PB05	Pin	= 37
-	PB06	Pin	= 38
-	PB07	Pin	= 39
-	PB08	Pin	= 40
-	PB09	Pin	= 41
-	PB10	Pin	= 42
-	PB11	Pin	= 43
-	PB12	Pin	= 44
-	PB13	Pin	= 45
-	PB14	Pin	= 46
-	PB15	Pin	= 47
-	PB16	Pin	= 48
-	PB17	Pin	= 49
-	PB18	Pin	= 50
-	PB19	Pin	= 51
-	PB20	Pin	= 52
-	PB21	Pin	= 53
-	PB22	Pin	= 54
-	PB23	Pin	= 55
-	PB24	Pin	= 56
-	PB25	Pin	= 57
-	PB26	Pin	= 58
-	PB27	Pin	= 59
-	PB28	Pin	= 60
-	PB29	Pin	= 61
-	PB30	Pin	= 62
-	PB31	Pin	= 63
-)
-```
-
-Hardware pins
-
-
-```go
-const RESET_MAGIC_VALUE = 0xf01669ef
-```
-
-used to reset into bootloader
-
-
-```go
-const (
-	D0	= PA11	// UART0 RX
-	D1	= PA10	// UART0 TX
-	D2	= PA14
-	D3	= PA09	// PWM available
-	D4	= PA08	// PWM available
-	D5	= PA15	// PWM available
-	D6	= PA20	// PWM available
-	D7	= PA21	// PWM available
-	D8	= PA06	// PWM available
-	D9	= PA07	// PWM available
-	D10	= PA18	// can be used for PWM or UART1 TX
-	D11	= PA16	// can be used for PWM or UART1 RX
-	D12	= PA19	// PWM available
-	D13	= PA17	// PWM available
-)
-```
-
-GPIO Pins
-
-
-```go
-const (
-	A0	= PA02	// ADC/AIN[0]
-	A1	= PB08	// ADC/AIN[2]
-	A2	= PB09	// ADC/AIN[3]
-	A3	= PA04	// ADC/AIN[4]
-	A4	= PA05	// ADC/AIN[5]
-	A5	= PB02	// ADC/AIN[10]
-)
-```
-
-Analog pins
-
-
-```go
-const (
-	LED = D13
-)
-```
-
-
-
-```go
-const (
-	USBCDC_DM_PIN	= PA24
-	USBCDC_DP_PIN	= PA25
-)
-```
-
-UART0 aka USBCDC pins
-
-
-```go
-const (
-	UART_TX_PIN	= D10
-	UART_RX_PIN	= D11
-)
-```
-
-UART1 pins
-
-
-```go
-const (
-	SDA_PIN	= PA22	// SDA: SERCOM3/PAD[0]
-	SCL_PIN	= PA23	// SCL: SERCOM3/PAD[1]
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	= PB11	// SCK: SERCOM4/PAD[3]
-	SPI0_SDO_PIN	= PB10	// SDO: SERCOM4/PAD[2]
-	SPI0_SDI_PIN	= PA12	// SDI: SERCOM4/PAD[0]
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	SPI1_CS_PIN	= PA27
-	SPI1_SCK_PIN	= PB23
-	SPI1_SDO_PIN	= PB22
-	SPI1_SDI_PIN	= PB03
-)
-```
-
-"Internal" SPI pins; SPI flash is attached to these on ItsyBitsy M0
-
-
-```go
-const (
-	I2S_SCK_PIN	= PA10
-	I2S_SD_PIN	= PA08
-	I2S_WS_PIN	= NoPin	// TODO: figure out what this is on ItsyBitsy M0.
-)
-```
-
-I2S pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const (
-	I2SModeSource	I2SMode	= iota
-	I2SModeReceiver
-	I2SModePDM
-)
-```
-
-
-
-```go
-const (
-	I2StandardPhilips	I2SStandard	= iota
-	I2SStandardMSB
-	I2SStandardLSB
-)
-```
-
-
-
-```go
-const (
-	I2SClockSourceInternal	I2SClockSource	= iota
-	I2SClockSourceExternal
-)
-```
-
-
-
-```go
-const (
-	I2SDataFormatDefault	I2SDataFormat	= 0
-	I2SDataFormat8bit			= 8
-	I2SDataFormat16bit			= 16
-	I2SDataFormat24bit			= 24
-	I2SDataFormat32bit			= 32
-)
-```
-
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinAnalog	PinMode	= 1
-	PinSERCOM	PinMode	= 2
-	PinSERCOMAlt	PinMode	= 3
-	PinTimer	PinMode	= 4
-	PinTimerAlt	PinMode	= 5
-	PinCom		PinMode	= 6
-	//PinAC_CLK        PinMode = 7
-	PinDigital		PinMode	= 8
-	PinInput		PinMode	= 9
-	PinInputPullup		PinMode	= 10
-	PinOutput		PinMode	= 11
-	PinPWM			PinMode	= PinTimer
-	PinPWMAlt		PinMode	= PinTimerAlt
-	PinInputPulldown	PinMode	= 12
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
-	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
-	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	Mode0	= 0
-	Mode1	= 1
-	Mode2	= 2
-	Mode3	= 3
-)
-```
-
-SPI phase and polarity configs CPOL and CPHA
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART1 = UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	sam.SERCOM1_USART,
-		SERCOM:	1,
-	}
-)
-```
-
-UART1 on the ItsyBitsy M0.
-
-
-```go
-var (
-	I2C0 = I2C{
-		Bus:	sam.SERCOM3_I2CM,
-		SERCOM:	3,
-	}
-)
-```
-
-I2C on the ItsyBitsy M0.
-
-
-```go
-var (
-	SPI0 = SPI{
-		Bus:	sam.SERCOM4_SPI,
-		SERCOM:	4,
-	}
-)
-```
-
-SPI on the ItsyBitsy M0.
-
-
-```go
-var (
-	SPI1 = SPI{
-		Bus:	sam.SERCOM5_SPI,
-		SERCOM:	5,
-	}
-)
-```
-
-"Internal" SPI on Sercom 5
-
-
-```go
-var (
-	I2S0 = I2S{Bus: sam.I2S}
-)
-```
-
-I2S on the ItsyBitsy M0.
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	// UART0 is actually a USB CDC interface.
-	UART0 = USBCDC{Buffer: NewRingBuffer()}
-)
-```
-
-
-
-```go
-var (
-	DAC0 = DAC{}
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-Return the current CPU frequency in hertz.
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the PWM interface.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-### func ResetProcessor
-
-```go
-func ResetProcessor()
-```
-
-ResetProcessor should perform a system reset in preperation
-to switch to the bootloader to flash new firmware.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure()
-```
-
-Configure configures a ADCPin to be able to be used to read data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin, in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DAC
-
-```go
-type DAC struct {
-}
-```
-
-DAC on the SAMD21.
-
-
-
-### func (DAC) Configure
-
-```go
-func (dac DAC) Configure(config DACConfig)
-```
-
-Configure the DAC.
-output pin must already be configured.
-
-
-### func (DAC) Set
-
-```go
-func (dac DAC) Set(value uint16) error
-```
-
-Set writes a single 16-bit value to the DAC.
-Since the ATSAMD21 only has a 10-bit DAC, the passed-in value will be scaled down.
-
-
-
-
-## type DACConfig
-
-```go
-type DACConfig struct {
-}
-```
-
-DACConfig placeholder for future expansion.
-
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus	*sam.SERCOM_I2CM_Type
-	SERCOM	uint8
-}
-```
-
-I2C on the SAMD21.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig) error
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) SetBaudRate
-
-```go
-func (i2c I2C) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the I2C.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteByte
-
-```go
-func (i2c I2C) WriteByte(data byte) error
-```
-
-WriteByte writes a single byte to the I2C bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type I2S
-
-```go
-type I2S struct {
-	Bus *sam.I2S_Type
-}
-```
-
-I2S
-
-
-
-### func (I2S) Close
-
-```go
-func (i2s I2S) Close() error
-```
-
-Close the I2S bus.
-
-
-### func (I2S) Configure
-
-```go
-func (i2s I2S) Configure(config I2SConfig)
-```
-
-Configure is used to configure the I2S interface. You must call this
-before you can use the I2S bus.
-
-
-### func (I2S) Read
-
-```go
-func (i2s I2S) Read(p []uint32) (n int, err error)
-```
-
-Read data from the I2S bus into the provided slice.
-The I2S bus must already have been configured correctly.
-
-
-### func (I2S) Write
-
-```go
-func (i2s I2S) Write(p []uint32) (n int, err error)
-```
-
-Write data to the I2S bus from the provided slice.
-The I2S bus must already have been configured correctly.
-
-
-
-
-## type I2SClockSource
-
-```go
-type I2SClockSource uint8
-```
-
-
-
-
-
-
-## type I2SConfig
-
-```go
-type I2SConfig struct {
-	SCK		Pin
-	WS		Pin
-	SD		Pin
-	Mode		I2SMode
-	Standard	I2SStandard
-	ClockSource	I2SClockSource
-	DataFormat	I2SDataFormat
-	AudioFrequency	uint32
-	MainClockOutput	bool
-	Stereo		bool
-}
-```
-
-All fields are optional and may not be required or used on a particular platform.
-
-
-
-
-
-## type I2SDataFormat
-
-```go
-type I2SDataFormat uint8
-```
-
-
-
-
-
-
-## type I2SMode
-
-```go
-type I2SMode uint8
-```
-
-
-
-
-
-
-## type I2SStandard
-
-```go
-type I2SStandard uint8
-```
-
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure() error
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus	*sam.SERCOM_SPI_Type
-	SERCOM	uint8
-}
-```
-
-SPI
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig) error
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer		*RingBuffer
-	Bus		*sam.SERCOM_USART_Type
-	SERCOM		uint8
-	Interrupt	interrupt.Interrupt
-}
-```
-
-UART on the SAMD21.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig) error
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer *RingBuffer
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the SAMD21.
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (USBCDC) Configure
-
-```go
-func (usbcdc USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/itsybitsy-m4.md b/content/microcontrollers/machine/itsybitsy-m4.md
deleted file mode 100644
index 904ed8a1..00000000
--- a/content/microcontrollers/machine/itsybitsy-m4.md
+++ /dev/null
@@ -1,1680 +0,0 @@
-
----
-title: itsybitsy-m4
----
-
-
-## Constants
-
-```go
-const RESET_MAGIC_VALUE = 0xf01669ef
-```
-
-used to reset into bootloader
-
-
-```go
-const (
-	D0	= PA16	// UART0 RX/PWM available
-	D1	= PA17	// UART0 TX/PWM available
-	D2	= PA07
-	D3	= PB22
-	D4	= PA14	// PWM available
-	D5	= PA15	// PWM available
-	D6	= PB02	// dotStar clock
-	D7	= PA18	// PWM available
-	D8	= PB03	// dotStar data
-	D9	= PA19	// PWM available
-	D10	= PA20	// can be used for PWM or UART1 TX
-	D11	= PA21	// can be used for PWM or UART1 RX
-	D12	= PA23	// PWM available
-	D13	= PA22	// PWM available
-)
-```
-
-GPIO Pins
-
-
-```go
-const (
-	A0	= PA02	// ADC/AIN[0]
-	A1	= PA05	// ADC/AIN[2]
-	A2	= PB08	// ADC/AIN[3]
-	A3	= PB09	// ADC/AIN[4]
-	A4	= PA04	// ADC/AIN[5]
-	A5	= PA06	// ADC/AIN[10]
-)
-```
-
-Analog pins
-
-
-```go
-const (
-	LED = D13
-)
-```
-
-
-
-```go
-const (
-	USBCDC_DM_PIN	= PA24
-	USBCDC_DP_PIN	= PA25
-)
-```
-
-UART0 aka USBCDC pins
-
-
-```go
-const (
-	UART_TX_PIN	= D1
-	UART_RX_PIN	= D0
-)
-```
-
-UART1 pins
-
-
-```go
-const (
-	UART2_TX_PIN	= A4
-	UART2_RX_PIN	= D2
-)
-```
-
-
-
-```go
-const (
-	SDA_PIN	= PA12	// SDA: SERCOM2/PAD[0]
-	SCL_PIN	= PA13	// SCL: SERCOM2/PAD[1]
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	= PA01	// SCK: SERCOM1/PAD[1]
-	SPI0_SDO_PIN	= PA00	// SDO: SERCOM1/PAD[0]
-	SPI0_SDI_PIN	= PB23	// SDI: SERCOM1/PAD[3]
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const (
-	I2SModeSource	I2SMode	= iota
-	I2SModeReceiver
-	I2SModePDM
-)
-```
-
-
-
-```go
-const (
-	I2StandardPhilips	I2SStandard	= iota
-	I2SStandardMSB
-	I2SStandardLSB
-)
-```
-
-
-
-```go
-const (
-	I2SClockSourceInternal	I2SClockSource	= iota
-	I2SClockSourceExternal
-)
-```
-
-
-
-```go
-const (
-	I2SDataFormatDefault	I2SDataFormat	= 0
-	I2SDataFormat8bit			= 8
-	I2SDataFormat16bit			= 16
-	I2SDataFormat24bit			= 24
-	I2SDataFormat32bit			= 32
-)
-```
-
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinAnalog		PinMode	= 1
-	PinSERCOM		PinMode	= 2
-	PinSERCOMAlt		PinMode	= 3
-	PinTimer		PinMode	= 4
-	PinTimerAlt		PinMode	= 5
-	PinTCCPDEC		PinMode	= 6
-	PinCom			PinMode	= 7
-	PinSDHC			PinMode	= 8
-	PinI2S			PinMode	= 9
-	PinPCC			PinMode	= 10
-	PinGMAC			PinMode	= 11
-	PinACCLK		PinMode	= 12
-	PinCCL			PinMode	= 13
-	PinDigital		PinMode	= 14
-	PinInput		PinMode	= 15
-	PinInputPullup		PinMode	= 16
-	PinOutput		PinMode	= 17
-	PinPWME			PinMode	= PinTimer
-	PinPWMF			PinMode	= PinTimerAlt
-	PinPWMG			PinMode	= PinTCCPDEC
-	PinInputPulldown	PinMode	= 18
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
-	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
-	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	PA00	Pin	= 0
-	PA01	Pin	= 1
-	PA02	Pin	= 2
-	PA03	Pin	= 3
-	PA04	Pin	= 4
-	PA05	Pin	= 5
-	PA06	Pin	= 6
-	PA07	Pin	= 7
-	PA08	Pin	= 8
-	PA09	Pin	= 9
-	PA10	Pin	= 10
-	PA11	Pin	= 11
-	PA12	Pin	= 12
-	PA13	Pin	= 13
-	PA14	Pin	= 14
-	PA15	Pin	= 15
-	PA16	Pin	= 16
-	PA17	Pin	= 17
-	PA18	Pin	= 18
-	PA19	Pin	= 19
-	PA20	Pin	= 20
-	PA21	Pin	= 21
-	PA22	Pin	= 22
-	PA23	Pin	= 23
-	PA24	Pin	= 24
-	PA25	Pin	= 25
-	PA26	Pin	= 26
-	PA27	Pin	= 27
-	PA28	Pin	= 28
-	PA29	Pin	= 29
-	PA30	Pin	= 30
-	PA31	Pin	= 31
-	PB00	Pin	= 32
-	PB01	Pin	= 33
-	PB02	Pin	= 34
-	PB03	Pin	= 35
-	PB04	Pin	= 36
-	PB05	Pin	= 37
-	PB06	Pin	= 38
-	PB07	Pin	= 39
-	PB08	Pin	= 40
-	PB09	Pin	= 41
-	PB10	Pin	= 42
-	PB11	Pin	= 43
-	PB12	Pin	= 44
-	PB13	Pin	= 45
-	PB14	Pin	= 46
-	PB15	Pin	= 47
-	PB16	Pin	= 48
-	PB17	Pin	= 49
-	PB18	Pin	= 50
-	PB19	Pin	= 51
-	PB20	Pin	= 52
-	PB21	Pin	= 53
-	PB22	Pin	= 54
-	PB23	Pin	= 55
-	PB24	Pin	= 56
-	PB25	Pin	= 57
-	PB26	Pin	= 58
-	PB27	Pin	= 59
-	PB28	Pin	= 60
-	PB29	Pin	= 61
-	PB30	Pin	= 62
-	PB31	Pin	= 63
-	PC00	Pin	= 64
-	PC01	Pin	= 65
-	PC02	Pin	= 66
-	PC03	Pin	= 67
-	PC04	Pin	= 68
-	PC05	Pin	= 69
-	PC06	Pin	= 70
-	PC07	Pin	= 71
-	PC08	Pin	= 72
-	PC09	Pin	= 73
-	PC10	Pin	= 74
-	PC11	Pin	= 75
-	PC12	Pin	= 76
-	PC13	Pin	= 77
-	PC14	Pin	= 78
-	PC15	Pin	= 79
-	PC16	Pin	= 80
-	PC17	Pin	= 81
-	PC18	Pin	= 82
-	PC19	Pin	= 83
-	PC20	Pin	= 84
-	PC21	Pin	= 85
-	PC22	Pin	= 86
-	PC23	Pin	= 87
-	PC24	Pin	= 88
-	PC25	Pin	= 89
-	PC26	Pin	= 90
-	PC27	Pin	= 91
-	PC28	Pin	= 92
-	PC29	Pin	= 93
-	PC30	Pin	= 94
-	PC31	Pin	= 95
-	PD00	Pin	= 96
-	PD01	Pin	= 97
-	PD02	Pin	= 98
-	PD03	Pin	= 99
-	PD04	Pin	= 100
-	PD05	Pin	= 101
-	PD06	Pin	= 102
-	PD07	Pin	= 103
-	PD08	Pin	= 104
-	PD09	Pin	= 105
-	PD10	Pin	= 106
-	PD11	Pin	= 107
-	PD12	Pin	= 108
-	PD13	Pin	= 109
-	PD14	Pin	= 110
-	PD15	Pin	= 111
-	PD16	Pin	= 112
-	PD17	Pin	= 113
-	PD18	Pin	= 114
-	PD19	Pin	= 115
-	PD20	Pin	= 116
-	PD21	Pin	= 117
-	PD22	Pin	= 118
-	PD23	Pin	= 119
-	PD24	Pin	= 120
-	PD25	Pin	= 121
-	PD26	Pin	= 122
-	PD27	Pin	= 123
-	PD28	Pin	= 124
-	PD29	Pin	= 125
-	PD30	Pin	= 126
-	PD31	Pin	= 127
-)
-```
-
-Hardware pins
-
-
-```go
-const (
-	// SERCOM_FREQ_REF is always reference frequency on SAMD51 regardless of CPU speed.
-	SERCOM_FREQ_REF	= 48000000
-
-	// Default rise time in nanoseconds, based on 4.7K ohm pull up resistors
-	riseTimeNanoseconds	= 125
-
-	// wire bus states
-	wireUnknownState	= 0
-	wireIdleState		= 1
-	wireOwnerState		= 2
-	wireBusyState		= 3
-
-	// wire commands
-	wireCmdNoAction		= 0
-	wireCmdRepeatStart	= 1
-	wireCmdRead		= 2
-	wireCmdStop		= 3
-)
-```
-
-
-
-```go
-const (
-	QSPI_SCK	= PB10
-	QSPI_CS		= PB11
-	QSPI_DATA0	= PA08
-	QSPI_DATA1	= PA09
-	QSPI_DATA2	= PA10
-	QSPI_DATA3	= PA11
-)
-```
-
-The QSPI peripheral on ATSAMD51 is only available on the following pins
-
-
-```go
-const HSRAM_SIZE = 0x00030000
-```
-
-
-
-```go
-const (
-	Mode0	= 0
-	Mode1	= 1
-	Mode2	= 2
-	Mode3	= 3
-)
-```
-
-SPI phase and polarity configs CPOL and CPHA
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART1	= UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	sam.SERCOM3_USART_INT,
-		SERCOM:	3,
-	}
-
-	UART2	= UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	sam.SERCOM0_USART_INT,
-		SERCOM:	0,
-	}
-)
-```
-
-
-
-```go
-var (
-	I2C0 = I2C{
-		Bus:	sam.SERCOM2_I2CM,
-		SERCOM:	2,
-	}
-)
-```
-
-I2C on the ItsyBitsy M4.
-
-
-```go
-var (
-	SPI0 = SPI{
-		Bus:	sam.SERCOM1_SPIM,
-		SERCOM:	1,
-	}
-)
-```
-
-SPI on the ItsyBitsy M4.
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	// UART0 is actually a USB CDC interface.
-	UART0 = USBCDC{Buffer: NewRingBuffer()}
-)
-```
-
-
-
-```go
-var (
-	DAC0 = DAC{}
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the PWM interface.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-### func ResetProcessor
-
-```go
-func ResetProcessor()
-```
-
-ResetProcessor should perform a system reset in preparation
-to switch to the bootloader to flash new firmware.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure()
-```
-
-Configure configures a ADCPin to be able to be used to read data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin, in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DAC
-
-```go
-type DAC struct {
-}
-```
-
-DAC on the SAMD51.
-
-
-
-### func (DAC) Configure
-
-```go
-func (dac DAC) Configure(config DACConfig)
-```
-
-Configure the DAC.
-output pin must already be configured.
-
-
-### func (DAC) Set
-
-```go
-func (dac DAC) Set(value uint16) error
-```
-
-Set writes a single 16-bit value to the DAC.
-Since the ATSAMD51 only has a 12-bit DAC, the passed-in value will be scaled down.
-
-
-
-
-## type DACConfig
-
-```go
-type DACConfig struct {
-}
-```
-
-DACConfig placeholder for future expansion.
-
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus	*sam.SERCOM_I2CM_Type
-	SERCOM	uint8
-}
-```
-
-I2C on the SAMD51.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig) error
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) SetBaudRate
-
-```go
-func (i2c I2C) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the I2C.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteByte
-
-```go
-func (i2c I2C) WriteByte(data byte) error
-```
-
-WriteByte writes a single byte to the I2C bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type I2SClockSource
-
-```go
-type I2SClockSource uint8
-```
-
-
-
-
-
-
-## type I2SConfig
-
-```go
-type I2SConfig struct {
-	SCK		Pin
-	WS		Pin
-	SD		Pin
-	Mode		I2SMode
-	Standard	I2SStandard
-	ClockSource	I2SClockSource
-	DataFormat	I2SDataFormat
-	AudioFrequency	uint32
-	MainClockOutput	bool
-	Stereo		bool
-}
-```
-
-All fields are optional and may not be required or used on a particular platform.
-
-
-
-
-
-## type I2SDataFormat
-
-```go
-type I2SDataFormat uint8
-```
-
-
-
-
-
-
-## type I2SMode
-
-```go
-type I2SMode uint8
-```
-
-
-
-
-
-
-## type I2SStandard
-
-```go
-type I2SStandard uint8
-```
-
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure() error
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-### func (Pin) Toggle
-
-```go
-func (p Pin) Toggle()
-```
-
-Toggle switches an output pin from low to high or from high to low.
-Warning: only use this on an output pin!
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus	*sam.SERCOM_SPIM_Type
-	SERCOM	uint8
-}
-```
-
-SPI
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig) error
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer		*RingBuffer
-	Bus		*sam.SERCOM_USART_INT_Type
-	SERCOM		uint8
-	Interrupt	interrupt.Interrupt	// RXC interrupt
-}
-```
-
-UART on the SAMD51.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig) error
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer *RingBuffer
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the SAMD21.
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (USBCDC) Configure
-
-```go
-func (usbcdc USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/itsybitsy-nrf52840.md b/content/microcontrollers/machine/itsybitsy-nrf52840.md
deleted file mode 100644
index 20603ff1..00000000
--- a/content/microcontrollers/machine/itsybitsy-nrf52840.md
+++ /dev/null
@@ -1,1391 +0,0 @@
-
----
-title: itsybitsy-nrf52840
----
-
-
-## Constants
-
-```go
-const HasLowFrequencyCrystal = true
-```
-
-
-
-```go
-const (
-	D0	= P0_25	// UART TX
-	D1	= P0_24	// UART RX
-	D2	= P1_02
-	D3	= P0_06	// LED1
-	D4	= P0_29	// Button
-	D5	= P0_27
-	D6	= P1_09	// DotStar Clock
-	D7	= P1_08
-	D8	= P0_08	// DotStar Data
-	D9	= P0_07
-	D10	= P0_05
-	D11	= P0_26
-	D12	= P0_11
-	D13	= P0_12
-	D14	= P0_04	// A0
-	D15	= P0_30	// A1
-	D16	= P0_28	// A2
-	D17	= P0_31	// A3
-	D18	= P0_02	// A4
-	D19	= P0_03	// A5
-	D20	= P0_05	// A6
-	D21	= P0_16	// I2C SDA
-	D22	= P0_14	// I2C SCL
-	D23	= P0_20	// SPI SDI
-	D24	= P0_15	// SPI SDO
-	D25	= P0_13	// SPI SCK
-	D26	= P0_19	// QSPI SCK
-	D27	= P0_23	// QSPI CS
-	D28	= P0_21	// QSPI Data 0
-	D29	= P0_22	// QSPI Data 1
-	D30	= P1_00	// QSPI Data 2
-	D31	= P0_17	// QSPI Data 3
-)
-```
-
-GPIO Pins
-
-
-```go
-const (
-	A0	= D14
-	A1	= D15
-	A2	= D16
-	A3	= D17
-	A4	= D18
-	A5	= D19
-	A6	= D20
-)
-```
-
-Analog Pins
-
-
-```go
-const (
-	LED	= D3
-	LED1	= LED
-	BUTTON	= D4
-
-	QSPI_SCK	= D26
-	QSPI_CS		= D27
-	QSPI_DATA0	= D28
-	QSPI_DATA1	= D29
-	QSPI_DATA2	= D30
-	QSPI_DATA3	= D31
-)
-```
-
-
-
-```go
-const (
-	UART_RX_PIN	= D0
-	UART_TX_PIN	= D1
-)
-```
-
-UART0 pins (logical UART1)
-
-
-```go
-const (
-	SDA_PIN	= D21	// I2C0 external
-	SCL_PIN	= D22	// I2C0 external
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	= D25
-	SPI0_SDO_PIN	= D24
-	SPI0_SDI_PIN	= D23
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Disconnect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
-	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
-	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	P0_00	Pin	= 0
-	P0_01	Pin	= 1
-	P0_02	Pin	= 2
-	P0_03	Pin	= 3
-	P0_04	Pin	= 4
-	P0_05	Pin	= 5
-	P0_06	Pin	= 6
-	P0_07	Pin	= 7
-	P0_08	Pin	= 8
-	P0_09	Pin	= 9
-	P0_10	Pin	= 10
-	P0_11	Pin	= 11
-	P0_12	Pin	= 12
-	P0_13	Pin	= 13
-	P0_14	Pin	= 14
-	P0_15	Pin	= 15
-	P0_16	Pin	= 16
-	P0_17	Pin	= 17
-	P0_18	Pin	= 18
-	P0_19	Pin	= 19
-	P0_20	Pin	= 20
-	P0_21	Pin	= 21
-	P0_22	Pin	= 22
-	P0_23	Pin	= 23
-	P0_24	Pin	= 24
-	P0_25	Pin	= 25
-	P0_26	Pin	= 26
-	P0_27	Pin	= 27
-	P0_28	Pin	= 28
-	P0_29	Pin	= 29
-	P0_30	Pin	= 30
-	P0_31	Pin	= 31
-	P1_00	Pin	= 32
-	P1_01	Pin	= 33
-	P1_02	Pin	= 34
-	P1_03	Pin	= 35
-	P1_04	Pin	= 36
-	P1_05	Pin	= 37
-	P1_06	Pin	= 38
-	P1_07	Pin	= 39
-	P1_08	Pin	= 40
-	P1_09	Pin	= 41
-	P1_10	Pin	= 42
-	P1_11	Pin	= 43
-	P1_12	Pin	= 44
-	P1_13	Pin	= 45
-	P1_14	Pin	= 46
-	P1_15	Pin	= 47
-)
-```
-
-Hardware pins
-
-
-```go
-const (
-	DFU_MAGIC_SERIAL_ONLY_RESET	= 0x4e
-	DFU_MAGIC_UF2_RESET		= 0x57
-	DFU_MAGIC_OTA_RESET		= 0xA8
-)
-```
-
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART0 = USB
-)
-```
-
-UART0 is the USB device
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-```go
-var (
-	// NRF_UART0 is the hardware UART on the NRF SoC.
-	NRF_UART0 = UART{Buffer: NewRingBuffer()}
-)
-```
-
-UART
-
-
-```go
-var (
-	I2C0	= I2C{Bus: nrf.TWI0}
-	I2C1	= I2C{Bus: nrf.TWI1}
-)
-```
-
-There are 2 I2C interfaces on the NRF.
-
-
-```go
-var (
-	SPI0	= SPI{Bus: nrf.SPI0}
-	SPI1	= SPI{Bus: nrf.SPI1}
-)
-```
-
-There are 2 SPI interfaces on the NRF5x.
-
-
-```go
-var (
-	USB	= USBCDC{Buffer: NewRingBuffer()}
-
-	usbEndpointDescriptors	[8]usbDeviceDescriptor
-
-	udd_ep_in_cache_buffer	[7][128]uint8
-	udd_ep_out_cache_buffer	[7][128]uint8
-
-	sendOnEP0DATADONE	struct {
-		ptr	*byte
-		count	int
-	}
-	isEndpointHalt		= false
-	isRemoteWakeUpEnabled	= false
-	endPoints		= []uint32{usb_ENDPOINT_TYPE_CONTROL,
-		(usb_ENDPOINT_TYPE_INTERRUPT | usbEndpointIn),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointOut),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointIn)}
-
-	usbConfiguration		uint8
-	usbSetInterface			uint8
-	usbLineInfo			= cdcLineInfo{115200, 0x00, 0x00, 0x08, 0x00}
-	epinen				uint32
-	epouten				uint32
-	easyDMABusy			volatile.Register8
-	epout0data_setlinecoding	bool
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func EnterOTABootloader
-
-```go
-func EnterOTABootloader()
-```
-
-EnterOTABootloader resets the chip into the bootloader so that it can be
-flashed via an OTA update
-
-
-### func EnterSerialBootloader
-
-```go
-func EnterSerialBootloader()
-```
-
-EnterSerialBootloader resets the chip into the serial bootloader. After
-reset, it can be flashed using serial/nrfutil.
-
-
-### func EnterUF2Bootloader
-
-```go
-func EnterUF2Bootloader()
-```
-
-EnterUF2Bootloader resets the chip into the UF2 bootloader. After reset, it
-can be flashed via nrfutil or by copying a UF2 file to the mass storage device
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the registers needed for ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the registers needed for PWM.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure() error
-```
-
-Configure configures an ADC pin to be able to read analog data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus *nrf.TWI_Type
-}
-```
-
-I2C on the NRF.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) (err error)
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure()
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *nrf.SPI_Type
-}
-```
-
-SPI on the NRF.
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the NRF.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer		*RingBuffer
-	interrupt	interrupt.Interrupt
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the nRF52840
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (*USBCDC) Configure
-
-```go
-func (usbcdc *USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/metro-m4-airlift.md b/content/microcontrollers/machine/metro-m4-airlift.md
deleted file mode 100644
index 798558cf..00000000
--- a/content/microcontrollers/machine/metro-m4-airlift.md
+++ /dev/null
@@ -1,1724 +0,0 @@
-
----
-title: metro-m4-airlift
----
-
-
-## Constants
-
-```go
-const RESET_MAGIC_VALUE = 0xf01669ef
-```
-
-used to reset into bootloader
-
-
-```go
-const (
-	D0	= PA23	// UART0 RX/PWM available
-	D1	= PA22	// UART0 TX/PWM available
-	D2	= PB17	// PWM available
-	D3	= PB16	// PWM available
-	D4	= PB13	// PWM available
-	D5	= PB14	// PWM available
-	D6	= PB15	// PWM available
-	D7	= PB12	// PWM available
-
-	D8	= PA21	// PWM available
-	D9	= PA20	// PWM available
-	D10	= PA18	// can be used for PWM or UART1 TX
-	D11	= PA19	// can be used for PWM or UART1 RX
-	D12	= PA17	// PWM available
-	D13	= PA16	// PWM available
-
-	D40	= PB22	// built-in neopixel
-)
-```
-
-GPIO Pins
-
-
-```go
-const (
-	A0	= PA02	// ADC/AIN[0]
-	A1	= PA05	// ADC/AIN[2]
-	A2	= PB06	// ADC/AIN[3]
-	A3	= PB00	// ADC/AIN[4] // NOTE: different between "airlift" and non-airlift versions
-	A4	= PB08	// ADC/AIN[5]
-	A5	= PB09	// ADC/AIN[10]
-)
-```
-
-Analog pins
-
-
-```go
-const (
-	LED = D13
-)
-```
-
-
-
-```go
-const (
-	USBCDC_DM_PIN	= PA24
-	USBCDC_DP_PIN	= PA25
-)
-```
-
-UART0 aka USBCDC pins
-
-
-```go
-const (
-	UART_TX_PIN	= D1
-	UART_RX_PIN	= D0
-)
-```
-
-
-
-```go
-const (
-	UART2_TX_PIN	= PA04
-	UART2_RX_PIN	= PA07
-)
-```
-
-
-
-```go
-const (
-	NINA_CS		= PA15
-	NINA_ACK	= PB04
-	NINA_GPIO0	= PB01
-	NINA_RESETN	= PB05
-
-	NINA_TX		= PA04
-	NINA_RX		= PA07
-	NINA_RTS	= PB23
-)
-```
-
-
-
-```go
-const (
-	SDA_PIN	= PB02	// SDA: SERCOM5/PAD[0]
-	SCL_PIN	= PB03	// SCL: SERCOM5/PAD[1]
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	= PA13	// SCK:  SERCOM2/PAD[1]
-	SPI0_SDO_PIN	= PA12	// SDO: SERCOM2/PAD[0]
-	SPI0_SDI_PIN	= PA14	// SDI: SERCOM2/PAD[2]
-
-	NINA_SDO	= SPI0_SDO_PIN
-	NINA_SDI	= SPI0_SDI_PIN
-	NINA_SCK	= SPI0_SCK_PIN
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	SPI1_SCK_PIN	= D12	// SDI: SERCOM1/PAD[1]
-	SPI1_SDO_PIN	= D11	// SDO: SERCOM1/PAD[3]
-	SPI1_SDI_PIN	= D13	// SCK:  SERCOM1/PAD[0]
-)
-```
-
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const (
-	I2SModeSource	I2SMode	= iota
-	I2SModeReceiver
-	I2SModePDM
-)
-```
-
-
-
-```go
-const (
-	I2StandardPhilips	I2SStandard	= iota
-	I2SStandardMSB
-	I2SStandardLSB
-)
-```
-
-
-
-```go
-const (
-	I2SClockSourceInternal	I2SClockSource	= iota
-	I2SClockSourceExternal
-)
-```
-
-
-
-```go
-const (
-	I2SDataFormatDefault	I2SDataFormat	= 0
-	I2SDataFormat8bit			= 8
-	I2SDataFormat16bit			= 16
-	I2SDataFormat24bit			= 24
-	I2SDataFormat32bit			= 32
-)
-```
-
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinAnalog		PinMode	= 1
-	PinSERCOM		PinMode	= 2
-	PinSERCOMAlt		PinMode	= 3
-	PinTimer		PinMode	= 4
-	PinTimerAlt		PinMode	= 5
-	PinTCCPDEC		PinMode	= 6
-	PinCom			PinMode	= 7
-	PinSDHC			PinMode	= 8
-	PinI2S			PinMode	= 9
-	PinPCC			PinMode	= 10
-	PinGMAC			PinMode	= 11
-	PinACCLK		PinMode	= 12
-	PinCCL			PinMode	= 13
-	PinDigital		PinMode	= 14
-	PinInput		PinMode	= 15
-	PinInputPullup		PinMode	= 16
-	PinOutput		PinMode	= 17
-	PinPWME			PinMode	= PinTimer
-	PinPWMF			PinMode	= PinTimerAlt
-	PinPWMG			PinMode	= PinTCCPDEC
-	PinInputPulldown	PinMode	= 18
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
-	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
-	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	PA00	Pin	= 0
-	PA01	Pin	= 1
-	PA02	Pin	= 2
-	PA03	Pin	= 3
-	PA04	Pin	= 4
-	PA05	Pin	= 5
-	PA06	Pin	= 6
-	PA07	Pin	= 7
-	PA08	Pin	= 8
-	PA09	Pin	= 9
-	PA10	Pin	= 10
-	PA11	Pin	= 11
-	PA12	Pin	= 12
-	PA13	Pin	= 13
-	PA14	Pin	= 14
-	PA15	Pin	= 15
-	PA16	Pin	= 16
-	PA17	Pin	= 17
-	PA18	Pin	= 18
-	PA19	Pin	= 19
-	PA20	Pin	= 20
-	PA21	Pin	= 21
-	PA22	Pin	= 22
-	PA23	Pin	= 23
-	PA24	Pin	= 24
-	PA25	Pin	= 25
-	PA26	Pin	= 26
-	PA27	Pin	= 27
-	PA28	Pin	= 28
-	PA29	Pin	= 29
-	PA30	Pin	= 30
-	PA31	Pin	= 31
-	PB00	Pin	= 32
-	PB01	Pin	= 33
-	PB02	Pin	= 34
-	PB03	Pin	= 35
-	PB04	Pin	= 36
-	PB05	Pin	= 37
-	PB06	Pin	= 38
-	PB07	Pin	= 39
-	PB08	Pin	= 40
-	PB09	Pin	= 41
-	PB10	Pin	= 42
-	PB11	Pin	= 43
-	PB12	Pin	= 44
-	PB13	Pin	= 45
-	PB14	Pin	= 46
-	PB15	Pin	= 47
-	PB16	Pin	= 48
-	PB17	Pin	= 49
-	PB18	Pin	= 50
-	PB19	Pin	= 51
-	PB20	Pin	= 52
-	PB21	Pin	= 53
-	PB22	Pin	= 54
-	PB23	Pin	= 55
-	PB24	Pin	= 56
-	PB25	Pin	= 57
-	PB26	Pin	= 58
-	PB27	Pin	= 59
-	PB28	Pin	= 60
-	PB29	Pin	= 61
-	PB30	Pin	= 62
-	PB31	Pin	= 63
-	PC00	Pin	= 64
-	PC01	Pin	= 65
-	PC02	Pin	= 66
-	PC03	Pin	= 67
-	PC04	Pin	= 68
-	PC05	Pin	= 69
-	PC06	Pin	= 70
-	PC07	Pin	= 71
-	PC08	Pin	= 72
-	PC09	Pin	= 73
-	PC10	Pin	= 74
-	PC11	Pin	= 75
-	PC12	Pin	= 76
-	PC13	Pin	= 77
-	PC14	Pin	= 78
-	PC15	Pin	= 79
-	PC16	Pin	= 80
-	PC17	Pin	= 81
-	PC18	Pin	= 82
-	PC19	Pin	= 83
-	PC20	Pin	= 84
-	PC21	Pin	= 85
-	PC22	Pin	= 86
-	PC23	Pin	= 87
-	PC24	Pin	= 88
-	PC25	Pin	= 89
-	PC26	Pin	= 90
-	PC27	Pin	= 91
-	PC28	Pin	= 92
-	PC29	Pin	= 93
-	PC30	Pin	= 94
-	PC31	Pin	= 95
-	PD00	Pin	= 96
-	PD01	Pin	= 97
-	PD02	Pin	= 98
-	PD03	Pin	= 99
-	PD04	Pin	= 100
-	PD05	Pin	= 101
-	PD06	Pin	= 102
-	PD07	Pin	= 103
-	PD08	Pin	= 104
-	PD09	Pin	= 105
-	PD10	Pin	= 106
-	PD11	Pin	= 107
-	PD12	Pin	= 108
-	PD13	Pin	= 109
-	PD14	Pin	= 110
-	PD15	Pin	= 111
-	PD16	Pin	= 112
-	PD17	Pin	= 113
-	PD18	Pin	= 114
-	PD19	Pin	= 115
-	PD20	Pin	= 116
-	PD21	Pin	= 117
-	PD22	Pin	= 118
-	PD23	Pin	= 119
-	PD24	Pin	= 120
-	PD25	Pin	= 121
-	PD26	Pin	= 122
-	PD27	Pin	= 123
-	PD28	Pin	= 124
-	PD29	Pin	= 125
-	PD30	Pin	= 126
-	PD31	Pin	= 127
-)
-```
-
-Hardware pins
-
-
-```go
-const (
-	// SERCOM_FREQ_REF is always reference frequency on SAMD51 regardless of CPU speed.
-	SERCOM_FREQ_REF	= 48000000
-
-	// Default rise time in nanoseconds, based on 4.7K ohm pull up resistors
-	riseTimeNanoseconds	= 125
-
-	// wire bus states
-	wireUnknownState	= 0
-	wireIdleState		= 1
-	wireOwnerState		= 2
-	wireBusyState		= 3
-
-	// wire commands
-	wireCmdNoAction		= 0
-	wireCmdRepeatStart	= 1
-	wireCmdRead		= 2
-	wireCmdStop		= 3
-)
-```
-
-
-
-```go
-const (
-	QSPI_SCK	= PB10
-	QSPI_CS		= PB11
-	QSPI_DATA0	= PA08
-	QSPI_DATA1	= PA09
-	QSPI_DATA2	= PA10
-	QSPI_DATA3	= PA11
-)
-```
-
-The QSPI peripheral on ATSAMD51 is only available on the following pins
-
-
-```go
-const HSRAM_SIZE = 0x00030000
-```
-
-
-
-```go
-const (
-	Mode0	= 0
-	Mode1	= 1
-	Mode2	= 2
-	Mode3	= 3
-)
-```
-
-SPI phase and polarity configs CPOL and CPHA
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART1	= UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	sam.SERCOM3_USART_INT,
-		SERCOM:	3,
-	}
-
-	UART2	= UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	sam.SERCOM0_USART_INT,
-		SERCOM:	0,
-	}
-)
-```
-
-
-
-```go
-var (
-	I2C0 = I2C{
-		Bus:	sam.SERCOM5_I2CM,
-		SERCOM:	5,
-	}
-)
-```
-
-I2C on the Metro M4.
-
-
-```go
-var (
-	SPI0	= SPI{
-		Bus:	sam.SERCOM2_SPIM,
-		SERCOM:	2,
-	}
-	NINA_SPI	= SPI0
-)
-```
-
-SPI on the Metro M4.
-
-
-```go
-var (
-	SPI1 = SPI{
-		Bus:	sam.SERCOM1_SPIM,
-		SERCOM:	1,
-	}
-)
-```
-
-SPI1 on the Metro M4 on pins 11,12,13
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	// UART0 is actually a USB CDC interface.
-	UART0 = USBCDC{Buffer: NewRingBuffer()}
-)
-```
-
-
-
-```go
-var (
-	DAC0 = DAC{}
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the PWM interface.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-### func ResetProcessor
-
-```go
-func ResetProcessor()
-```
-
-ResetProcessor should perform a system reset in preparation
-to switch to the bootloader to flash new firmware.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure()
-```
-
-Configure configures a ADCPin to be able to be used to read data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin, in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DAC
-
-```go
-type DAC struct {
-}
-```
-
-DAC on the SAMD51.
-
-
-
-### func (DAC) Configure
-
-```go
-func (dac DAC) Configure(config DACConfig)
-```
-
-Configure the DAC.
-output pin must already be configured.
-
-
-### func (DAC) Set
-
-```go
-func (dac DAC) Set(value uint16) error
-```
-
-Set writes a single 16-bit value to the DAC.
-Since the ATSAMD51 only has a 12-bit DAC, the passed-in value will be scaled down.
-
-
-
-
-## type DACConfig
-
-```go
-type DACConfig struct {
-}
-```
-
-DACConfig placeholder for future expansion.
-
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus	*sam.SERCOM_I2CM_Type
-	SERCOM	uint8
-}
-```
-
-I2C on the SAMD51.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig) error
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) SetBaudRate
-
-```go
-func (i2c I2C) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the I2C.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteByte
-
-```go
-func (i2c I2C) WriteByte(data byte) error
-```
-
-WriteByte writes a single byte to the I2C bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type I2SClockSource
-
-```go
-type I2SClockSource uint8
-```
-
-
-
-
-
-
-## type I2SConfig
-
-```go
-type I2SConfig struct {
-	SCK		Pin
-	WS		Pin
-	SD		Pin
-	Mode		I2SMode
-	Standard	I2SStandard
-	ClockSource	I2SClockSource
-	DataFormat	I2SDataFormat
-	AudioFrequency	uint32
-	MainClockOutput	bool
-	Stereo		bool
-}
-```
-
-All fields are optional and may not be required or used on a particular platform.
-
-
-
-
-
-## type I2SDataFormat
-
-```go
-type I2SDataFormat uint8
-```
-
-
-
-
-
-
-## type I2SMode
-
-```go
-type I2SMode uint8
-```
-
-
-
-
-
-
-## type I2SStandard
-
-```go
-type I2SStandard uint8
-```
-
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure() error
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-### func (Pin) Toggle
-
-```go
-func (p Pin) Toggle()
-```
-
-Toggle switches an output pin from low to high or from high to low.
-Warning: only use this on an output pin!
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus	*sam.SERCOM_SPIM_Type
-	SERCOM	uint8
-}
-```
-
-SPI
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig) error
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer		*RingBuffer
-	Bus		*sam.SERCOM_USART_INT_Type
-	SERCOM		uint8
-	Interrupt	interrupt.Interrupt	// RXC interrupt
-}
-```
-
-UART on the SAMD51.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig) error
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer *RingBuffer
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the SAMD21.
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (USBCDC) Configure
-
-```go
-func (usbcdc USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/microbit-s110v8.md b/content/microcontrollers/machine/microbit-s110v8.md
deleted file mode 100644
index da38515f..00000000
--- a/content/microcontrollers/machine/microbit-s110v8.md
+++ /dev/null
@@ -1,710 +0,0 @@
-
----
-title: microbit-s110v8
----
-
-
-## Constants
-
-```go
-const HasLowFrequencyCrystal = false
-```
-
-The micro:bit does not have a 32kHz crystal on board.
-
-
-```go
-const (
-	BUTTON	Pin	= BUTTONA
-	BUTTONA	Pin	= 17
-	BUTTONB	Pin	= 26
-)
-```
-
-Buttons on the micro:bit (A and B)
-
-
-```go
-const (
-	UART_TX_PIN	Pin	= 24
-	UART_RX_PIN	Pin	= 25
-)
-```
-
-UART pins
-
-
-```go
-const (
-	ADC0	Pin	= 3	// P0 on the board
-	ADC1	Pin	= 2	// P1 on the board
-	ADC2	Pin	= 1	// P2 on the board
-)
-```
-
-ADC pins
-
-
-```go
-const (
-	SDA_PIN	Pin	= 30	// P20 on the board
-	SCL_PIN	Pin	= 0	// P19 on the board
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	Pin	= 23	// P13 on the board
-	SPI0_SDO_PIN	Pin	= 21	// P15 on the board
-	SPI0_SDI_PIN	Pin	= 22	// P14 on the board
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	P0	Pin	= 3
-	P1	Pin	= 2
-	P2	Pin	= 1
-	P3	Pin	= 4
-	P4	Pin	= 5
-	P5	Pin	= 17
-	P6	Pin	= 12
-	P7	Pin	= 11
-	P8	Pin	= 18
-	P9	Pin	= 10
-	P10	Pin	= 6
-	P11	Pin	= 26
-	P12	Pin	= 20
-	P13	Pin	= 23
-	P14	Pin	= 22
-	P15	Pin	= 21
-	P16	Pin	= 16
-)
-```
-
-GPIO/Analog pins
-
-
-```go
-const (
-	LED_COL_1	Pin	= 4
-	LED_COL_2	Pin	= 5
-	LED_COL_3	Pin	= 6
-	LED_COL_4	Pin	= 7
-	LED_COL_5	Pin	= 8
-	LED_COL_6	Pin	= 9
-	LED_COL_7	Pin	= 10
-	LED_COL_8	Pin	= 11
-	LED_COL_9	Pin	= 12
-	LED_ROW_1	Pin	= 13
-	LED_ROW_2	Pin	= 14
-	LED_ROW_3	Pin	= 15
-)
-```
-
-LED matrix pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Disconnect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
-	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
-	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-
-
-
-## Variables
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-```go
-var (
-	// NRF_UART0 is the hardware UART on the NRF SoC.
-	NRF_UART0 = UART{Buffer: NewRingBuffer()}
-)
-```
-
-UART
-
-
-```go
-var (
-	I2C0	= I2C{Bus: nrf.TWI0}
-	I2C1	= I2C{Bus: nrf.TWI1}
-)
-```
-
-There are 2 I2C interfaces on the NRF.
-
-
-```go
-var (
-	SPI0	= SPI{Bus: nrf.SPI0}
-	SPI1	= SPI{Bus: nrf.SPI1}
-)
-```
-
-There are 2 SPI interfaces on the NRF5x.
-
-
-```go
-var (
-	UART0 = NRF_UART0
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus *nrf.TWI_Type
-}
-```
-
-I2C on the NRF.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) (err error)
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *nrf.SPI_Type
-}
-```
-
-SPI on the NRF.
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the NRF.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/microbit.md b/content/microcontrollers/machine/microbit.md
deleted file mode 100644
index 241393b4..00000000
--- a/content/microcontrollers/machine/microbit.md
+++ /dev/null
@@ -1,710 +0,0 @@
-
----
-title: microbit
----
-
-
-## Constants
-
-```go
-const HasLowFrequencyCrystal = false
-```
-
-The micro:bit does not have a 32kHz crystal on board.
-
-
-```go
-const (
-	BUTTON	Pin	= BUTTONA
-	BUTTONA	Pin	= 17
-	BUTTONB	Pin	= 26
-)
-```
-
-Buttons on the micro:bit (A and B)
-
-
-```go
-const (
-	UART_TX_PIN	Pin	= 24
-	UART_RX_PIN	Pin	= 25
-)
-```
-
-UART pins
-
-
-```go
-const (
-	ADC0	Pin	= 3	// P0 on the board
-	ADC1	Pin	= 2	// P1 on the board
-	ADC2	Pin	= 1	// P2 on the board
-)
-```
-
-ADC pins
-
-
-```go
-const (
-	SDA_PIN	Pin	= 30	// P20 on the board
-	SCL_PIN	Pin	= 0	// P19 on the board
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	Pin	= 23	// P13 on the board
-	SPI0_SDO_PIN	Pin	= 21	// P15 on the board
-	SPI0_SDI_PIN	Pin	= 22	// P14 on the board
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	P0	Pin	= 3
-	P1	Pin	= 2
-	P2	Pin	= 1
-	P3	Pin	= 4
-	P4	Pin	= 5
-	P5	Pin	= 17
-	P6	Pin	= 12
-	P7	Pin	= 11
-	P8	Pin	= 18
-	P9	Pin	= 10
-	P10	Pin	= 6
-	P11	Pin	= 26
-	P12	Pin	= 20
-	P13	Pin	= 23
-	P14	Pin	= 22
-	P15	Pin	= 21
-	P16	Pin	= 16
-)
-```
-
-GPIO/Analog pins
-
-
-```go
-const (
-	LED_COL_1	Pin	= 4
-	LED_COL_2	Pin	= 5
-	LED_COL_3	Pin	= 6
-	LED_COL_4	Pin	= 7
-	LED_COL_5	Pin	= 8
-	LED_COL_6	Pin	= 9
-	LED_COL_7	Pin	= 10
-	LED_COL_8	Pin	= 11
-	LED_COL_9	Pin	= 12
-	LED_ROW_1	Pin	= 13
-	LED_ROW_2	Pin	= 14
-	LED_ROW_3	Pin	= 15
-)
-```
-
-LED matrix pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Disconnect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
-	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
-	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-
-
-
-## Variables
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-```go
-var (
-	// NRF_UART0 is the hardware UART on the NRF SoC.
-	NRF_UART0 = UART{Buffer: NewRingBuffer()}
-)
-```
-
-UART
-
-
-```go
-var (
-	I2C0	= I2C{Bus: nrf.TWI0}
-	I2C1	= I2C{Bus: nrf.TWI1}
-)
-```
-
-There are 2 I2C interfaces on the NRF.
-
-
-```go
-var (
-	SPI0	= SPI{Bus: nrf.SPI0}
-	SPI1	= SPI{Bus: nrf.SPI1}
-)
-```
-
-There are 2 SPI interfaces on the NRF5x.
-
-
-```go
-var (
-	UART0 = NRF_UART0
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus *nrf.TWI_Type
-}
-```
-
-I2C on the NRF.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) (err error)
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *nrf.SPI_Type
-}
-```
-
-SPI on the NRF.
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the NRF.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/nintendoswitch.md b/content/microcontrollers/machine/nintendoswitch.md
deleted file mode 100644
index c27512c2..00000000
--- a/content/microcontrollers/machine/nintendoswitch.md
+++ /dev/null
@@ -1,509 +0,0 @@
-
----
-title: nintendoswitch
----
-
-
-## Constants
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput	PinMode	= iota
-	PinOutput
-	PinInputPullup
-	PinInputPulldown
-)
-```
-
-
-
-```go
-const (
-	Mode0	= 0
-	Mode1	= 1
-	Mode2	= 2
-	Mode3	= 3
-)
-```
-
-SPI phase and polarity configs CPOL and CPHA
-
-
-
-
-
-## Variables
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	SPI0	= SPI{0}
-	I2C0	= I2C{0}
-	UART0	= UART{0}
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC enables support for ADC peripherals.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM enables support for PWM peripherals.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (adc ADC) Configure()
-```
-
-Configure configures an ADC pin to be able to be used to read data.
-
-
-### func (ADC) Get
-
-```go
-func (adc ADC) Get() uint16
-```
-
-Get reads the current analog value from this ADC peripheral.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus uint8
-}
-```
-
-I2C is a generic implementation of the Inter-IC communication protocol.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure() error
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(value bool)
-```
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus uint8
-}
-```
-
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	Mode		uint8
-}
-```
-
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Bus uint8
-}
-```
-
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the UART.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(b byte) error
-```
-
-WriteByte writes a single byte to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/nodemcu.md b/content/microcontrollers/machine/nodemcu.md
deleted file mode 100644
index 4faaf97c..00000000
--- a/content/microcontrollers/machine/nodemcu.md
+++ /dev/null
@@ -1,415 +0,0 @@
-
----
-title: nodemcu
----
-
-
-## Constants
-
-```go
-const (
-	D0	Pin	= 16
-	D1	Pin	= 5
-	D2	Pin	= 4
-	D3	Pin	= 0
-	D4	Pin	= 2
-	D5	Pin	= 14
-	D6	Pin	= 12
-	D7	Pin	= 13
-	D8	Pin	= 15
-)
-```
-
-GPIO pins on the NodeMCU board.
-
-
-```go
-const LED = D4
-```
-
-Onboard blue LED (on the AI-Thinker module).
-
-
-```go
-const (
-	SPI0_SCK_PIN	= D5
-	SPI0_SDO_PIN	= D7
-	SPI0_SDI_PIN	= D6
-	SPI0_CS0_PIN	= D8
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	SDA_PIN	= D2
-	SCL_PIN	= D1
-)
-```
-
-I2C pins
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinOutput	PinMode	= iota
-	PinInput
-)
-```
-
-
-
-```go
-const (
-	UART_TX_PIN	Pin	= 1
-	UART_RX_PIN	Pin	= 3
-)
-```
-
-Pins that are fixed by the chip.
-
-
-
-
-
-## Variables
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var UART0 = UART{Buffer: NewRingBuffer()}
-```
-
-UART0 is a hardware UART that supports both TX and RX.
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure sets the given pin as output or input pin.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin when the pin is configured as an
-input.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-Warning: only use this on an output pin!
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-Warning: only use this on an output pin!
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(value bool)
-```
-
-Set sets the output value of this pin to high (true) or low (false).
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART baud rate. TX and RX pins are fixed by the hardware so
-cannot be modified and will be ignored.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a single byte to the output buffer. Note that the hardware
-includes a buffer of 128 bytes which will be used first.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/nrf52840-mdk.md b/content/microcontrollers/machine/nrf52840-mdk.md
deleted file mode 100644
index 3aaaef8d..00000000
--- a/content/microcontrollers/machine/nrf52840-mdk.md
+++ /dev/null
@@ -1,1291 +0,0 @@
-
----
-title: nrf52840-mdk
----
-
-
-## Constants
-
-```go
-const HasLowFrequencyCrystal = true
-```
-
-
-
-```go
-const (
-	LED		Pin	= LED_GREEN
-	LED_GREEN	Pin	= 22
-	LED_RED		Pin	= 23
-	LED_BLUE	Pin	= 24
-)
-```
-
-LEDs on the nrf52840-mdk (nRF52840 dev board)
-
-
-```go
-const (
-	UART_TX_PIN	Pin	= 20
-	UART_RX_PIN	Pin	= 19
-)
-```
-
-UART pins
-
-
-```go
-const (
-	SDA_PIN	= NoPin
-	SCL_PIN	= NoPin
-)
-```
-
-I2C pins (unused)
-
-
-```go
-const (
-	SPI0_SCK_PIN	= NoPin
-	SPI0_SDO_PIN	= NoPin
-	SPI0_SDI_PIN	= NoPin
-)
-```
-
-SPI pins (unused)
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Disconnect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
-	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
-	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	P0_00	Pin	= 0
-	P0_01	Pin	= 1
-	P0_02	Pin	= 2
-	P0_03	Pin	= 3
-	P0_04	Pin	= 4
-	P0_05	Pin	= 5
-	P0_06	Pin	= 6
-	P0_07	Pin	= 7
-	P0_08	Pin	= 8
-	P0_09	Pin	= 9
-	P0_10	Pin	= 10
-	P0_11	Pin	= 11
-	P0_12	Pin	= 12
-	P0_13	Pin	= 13
-	P0_14	Pin	= 14
-	P0_15	Pin	= 15
-	P0_16	Pin	= 16
-	P0_17	Pin	= 17
-	P0_18	Pin	= 18
-	P0_19	Pin	= 19
-	P0_20	Pin	= 20
-	P0_21	Pin	= 21
-	P0_22	Pin	= 22
-	P0_23	Pin	= 23
-	P0_24	Pin	= 24
-	P0_25	Pin	= 25
-	P0_26	Pin	= 26
-	P0_27	Pin	= 27
-	P0_28	Pin	= 28
-	P0_29	Pin	= 29
-	P0_30	Pin	= 30
-	P0_31	Pin	= 31
-	P1_00	Pin	= 32
-	P1_01	Pin	= 33
-	P1_02	Pin	= 34
-	P1_03	Pin	= 35
-	P1_04	Pin	= 36
-	P1_05	Pin	= 37
-	P1_06	Pin	= 38
-	P1_07	Pin	= 39
-	P1_08	Pin	= 40
-	P1_09	Pin	= 41
-	P1_10	Pin	= 42
-	P1_11	Pin	= 43
-	P1_12	Pin	= 44
-	P1_13	Pin	= 45
-	P1_14	Pin	= 46
-	P1_15	Pin	= 47
-)
-```
-
-Hardware pins
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART0 = USB
-)
-```
-
-UART0 is the USB device
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-```go
-var (
-	// NRF_UART0 is the hardware UART on the NRF SoC.
-	NRF_UART0 = UART{Buffer: NewRingBuffer()}
-)
-```
-
-UART
-
-
-```go
-var (
-	I2C0	= I2C{Bus: nrf.TWI0}
-	I2C1	= I2C{Bus: nrf.TWI1}
-)
-```
-
-There are 2 I2C interfaces on the NRF.
-
-
-```go
-var (
-	SPI0	= SPI{Bus: nrf.SPI0}
-	SPI1	= SPI{Bus: nrf.SPI1}
-)
-```
-
-There are 2 SPI interfaces on the NRF5x.
-
-
-```go
-var (
-	USB	= USBCDC{Buffer: NewRingBuffer()}
-
-	usbEndpointDescriptors	[8]usbDeviceDescriptor
-
-	udd_ep_in_cache_buffer	[7][128]uint8
-	udd_ep_out_cache_buffer	[7][128]uint8
-
-	sendOnEP0DATADONE	struct {
-		ptr	*byte
-		count	int
-	}
-	isEndpointHalt		= false
-	isRemoteWakeUpEnabled	= false
-	endPoints		= []uint32{usb_ENDPOINT_TYPE_CONTROL,
-		(usb_ENDPOINT_TYPE_INTERRUPT | usbEndpointIn),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointOut),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointIn)}
-
-	usbConfiguration		uint8
-	usbSetInterface			uint8
-	usbLineInfo			= cdcLineInfo{115200, 0x00, 0x00, 0x08, 0x00}
-	epinen				uint32
-	epouten				uint32
-	easyDMABusy			volatile.Register8
-	epout0data_setlinecoding	bool
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the registers needed for ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the registers needed for PWM.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure() error
-```
-
-Configure configures an ADC pin to be able to read analog data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus *nrf.TWI_Type
-}
-```
-
-I2C on the NRF.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) (err error)
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure()
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *nrf.SPI_Type
-}
-```
-
-SPI on the NRF.
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the NRF.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer		*RingBuffer
-	interrupt	interrupt.Interrupt
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the nRF52840
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (*USBCDC) Configure
-
-```go
-func (usbcdc *USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/nucleo-f103rb.md b/content/microcontrollers/machine/nucleo-f103rb.md
deleted file mode 100644
index bb1ba467..00000000
--- a/content/microcontrollers/machine/nucleo-f103rb.md
+++ /dev/null
@@ -1,709 +0,0 @@
-
----
-title: nucleo-f103rb
----
-
-
-## Constants
-
-```go
-const (
-	PA0	= portA + 0
-	PA1	= portA + 1
-	PA2	= portA + 2
-	PA3	= portA + 3
-	PA4	= portA + 4
-	PA5	= portA + 5
-	PA6	= portA + 6
-	PA7	= portA + 7
-	PA8	= portA + 8
-	PA9	= portA + 9
-	PA10	= portA + 10
-	PA11	= portA + 11
-	PA12	= portA + 12
-	PA13	= portA + 13
-	PA14	= portA + 14
-	PA15	= portA + 15
-
-	PB0	= portB + 0
-	PB1	= portB + 1
-	PB2	= portB + 2
-	PB3	= portB + 3
-	PB4	= portB + 4
-	PB5	= portB + 5
-	PB6	= portB + 6
-	PB7	= portB + 7
-	PB8	= portB + 8
-	PB9	= portB + 9
-	PB10	= portB + 10
-	PB11	= portB + 11
-	PB12	= portB + 12
-	PB13	= portB + 13
-	PB14	= portB + 14
-	PB15	= portB + 15
-
-	PC0	= portC + 0
-	PC1	= portC + 1
-	PC2	= portC + 2
-	PC3	= portC + 3
-	PC4	= portC + 4
-	PC5	= portC + 5
-	PC6	= portC + 6
-	PC7	= portC + 7
-	PC8	= portC + 8
-	PC9	= portC + 9
-	PC10	= portC + 10
-	PC11	= portC + 11
-	PC12	= portC + 12
-	PC13	= portC + 13
-	PC14	= portC + 14
-	PC15	= portC + 15
-
-	PD0	= portD + 0
-	PD1	= portD + 1
-	PD2	= portD + 2
-	PD3	= portD + 3
-	PD4	= portD + 4
-	PD5	= portD + 5
-	PD6	= portD + 6
-	PD7	= portD + 7
-	PD8	= portD + 8
-	PD9	= portD + 9
-	PD10	= portD + 10
-	PD11	= portD + 11
-	PD12	= portD + 12
-	PD13	= portD + 13
-	PD14	= portD + 14
-	PD15	= portD + 15
-)
-```
-
-
-
-```go
-const (
-	LED		= LED_BUILTIN
-	LED_BUILTIN	= LED_GREEN
-	LED_GREEN	= PA5
-)
-```
-
-
-
-```go
-const (
-	BUTTON		= BUTTON_USER
-	BUTTON_USER	= PC13
-)
-```
-
-
-
-```go
-const (
-	UART_TX_PIN	= PA2
-	UART_RX_PIN	= PA3
-	UART_ALT_TX_PIN	= PD5
-	UART_ALT_RX_PIN	= PD6
-)
-```
-
-UART pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	= PA5
-	SPI0_SDI_PIN	= PA6
-	SPI0_SDO_PIN	= PA7
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	SCL_PIN	= PB6
-	SDA_PIN	= PB7
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput	PinMode	= 0	// Input mode
-	PinOutput10MHz	PinMode	= 1	// Output mode, max speed 10MHz
-	PinOutput2MHz	PinMode	= 2	// Output mode, max speed 2MHz
-	PinOutput50MHz	PinMode	= 3	// Output mode, max speed 50MHz
-	PinOutput	PinMode	= PinOutput2MHz
-
-	PinInputModeAnalog	PinMode	= 0	// Input analog mode
-	PinInputModeFloating	PinMode	= 4	// Input floating mode
-	PinInputModePullUpDown	PinMode	= 8	// Input pull up/down mode
-	PinInputModeReserved	PinMode	= 12	// Input mode (reserved)
-
-	PinOutputModeGPPushPull		PinMode	= 0	// Output mode general purpose push/pull
-	PinOutputModeGPOpenDrain	PinMode	= 4	// Output mode general purpose open drain
-	PinOutputModeAltPushPull	PinMode	= 8	// Output mode alt. purpose push/pull
-	PinOutputModeAltOpenDrain	PinMode	= 12	// Output mode alt. purpose open drain
-)
-```
-
-
-
-```go
-const (
-	Mode0	= 0
-	Mode1	= 1
-	Mode2	= 2
-	Mode3	= 3
-)
-```
-
-SPI phase and polarity configs CPOL and CPHA
-
-
-
-
-
-## Variables
-
-```go
-var (
-	// USART2 is the hardware serial port connected to the onboard ST-LINK
-	// debugger to be exposed as virtual COM port over USB on Nucleo boards.
-	// Both UART0 and UART1 refer to USART2.
-	UART0	= UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	stm32.USART2,
-	}
-	UART2	= &UART0
-)
-```
-
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	SPI1	= SPI{Bus: stm32.SPI1}
-	SPI0	= SPI1
-)
-```
-
-There are 3 SPI interfaces on the STM32F103xx.
-Since the first interface is named SPI1, both SPI0 and SPI1 refer to SPI1.
-TODO: implement SPI2 and SPI3.
-
-
-```go
-var (
-	I2C1	= I2C{Bus: stm32.I2C1}
-	I2C0	= I2C1
-)
-```
-
-There are 2 I2C interfaces on the STM32F103xx.
-Since the first interface is named I2C1, both I2C0 and I2C1 refer to I2C1.
-TODO: implement I2C2.
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus *stm32.I2C_Type
-}
-```
-
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteByte
-
-```go
-func (i2c I2C) WriteByte(data byte) error
-```
-
-WriteByte writes a single byte to the I2C bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given I/O settings.
-stm32f1xx uses different technique for setting the GPIO pins than the stm32f407
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *stm32.SPI_Type
-}
-```
-
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the STM32 SPI1 interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer		*RingBuffer
-	Bus		*stm32.USART_Type
-	Interrupt	interrupt.Interrupt
-}
-```
-
-UART representation
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART. Defer to chip-specific
-routines for calculation
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/particle-3rd-gen.md b/content/microcontrollers/machine/particle-3rd-gen.md
deleted file mode 100644
index f137240d..00000000
--- a/content/microcontrollers/machine/particle-3rd-gen.md
+++ /dev/null
@@ -1,1233 +0,0 @@
-
----
-title: particle-3rd-gen
----
-
-
-## Constants
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Disconnect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
-	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
-	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	P0_00	Pin	= 0
-	P0_01	Pin	= 1
-	P0_02	Pin	= 2
-	P0_03	Pin	= 3
-	P0_04	Pin	= 4
-	P0_05	Pin	= 5
-	P0_06	Pin	= 6
-	P0_07	Pin	= 7
-	P0_08	Pin	= 8
-	P0_09	Pin	= 9
-	P0_10	Pin	= 10
-	P0_11	Pin	= 11
-	P0_12	Pin	= 12
-	P0_13	Pin	= 13
-	P0_14	Pin	= 14
-	P0_15	Pin	= 15
-	P0_16	Pin	= 16
-	P0_17	Pin	= 17
-	P0_18	Pin	= 18
-	P0_19	Pin	= 19
-	P0_20	Pin	= 20
-	P0_21	Pin	= 21
-	P0_22	Pin	= 22
-	P0_23	Pin	= 23
-	P0_24	Pin	= 24
-	P0_25	Pin	= 25
-	P0_26	Pin	= 26
-	P0_27	Pin	= 27
-	P0_28	Pin	= 28
-	P0_29	Pin	= 29
-	P0_30	Pin	= 30
-	P0_31	Pin	= 31
-	P1_00	Pin	= 32
-	P1_01	Pin	= 33
-	P1_02	Pin	= 34
-	P1_03	Pin	= 35
-	P1_04	Pin	= 36
-	P1_05	Pin	= 37
-	P1_06	Pin	= 38
-	P1_07	Pin	= 39
-	P1_08	Pin	= 40
-	P1_09	Pin	= 41
-	P1_10	Pin	= 42
-	P1_11	Pin	= 43
-	P1_12	Pin	= 44
-	P1_13	Pin	= 45
-	P1_14	Pin	= 46
-	P1_15	Pin	= 47
-)
-```
-
-Hardware pins
-
-
-
-
-
-## Variables
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-```go
-var (
-	// NRF_UART0 is the hardware UART on the NRF SoC.
-	NRF_UART0 = UART{Buffer: NewRingBuffer()}
-)
-```
-
-UART
-
-
-```go
-var (
-	I2C0	= I2C{Bus: nrf.TWI0}
-	I2C1	= I2C{Bus: nrf.TWI1}
-)
-```
-
-There are 2 I2C interfaces on the NRF.
-
-
-```go
-var (
-	SPI0	= SPI{Bus: nrf.SPI0}
-	SPI1	= SPI{Bus: nrf.SPI1}
-)
-```
-
-There are 2 SPI interfaces on the NRF5x.
-
-
-```go
-var (
-	USB	= USBCDC{Buffer: NewRingBuffer()}
-
-	usbEndpointDescriptors	[8]usbDeviceDescriptor
-
-	udd_ep_in_cache_buffer	[7][128]uint8
-	udd_ep_out_cache_buffer	[7][128]uint8
-
-	sendOnEP0DATADONE	struct {
-		ptr	*byte
-		count	int
-	}
-	isEndpointHalt		= false
-	isRemoteWakeUpEnabled	= false
-	endPoints		= []uint32{usb_ENDPOINT_TYPE_CONTROL,
-		(usb_ENDPOINT_TYPE_INTERRUPT | usbEndpointIn),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointOut),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointIn)}
-
-	usbConfiguration		uint8
-	usbSetInterface			uint8
-	usbLineInfo			= cdcLineInfo{115200, 0x00, 0x00, 0x08, 0x00}
-	epinen				uint32
-	epouten				uint32
-	easyDMABusy			volatile.Register8
-	epout0data_setlinecoding	bool
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the registers needed for ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the registers needed for PWM.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure() error
-```
-
-Configure configures an ADC pin to be able to read analog data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus *nrf.TWI_Type
-}
-```
-
-I2C on the NRF.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) (err error)
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure()
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *nrf.SPI_Type
-}
-```
-
-SPI on the NRF.
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the NRF.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer		*RingBuffer
-	interrupt	interrupt.Interrupt
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the nRF52840
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (*USBCDC) Configure
-
-```go
-func (usbcdc *USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/particle-argon.md b/content/microcontrollers/machine/particle-argon.md
deleted file mode 100644
index 5c18ff8d..00000000
--- a/content/microcontrollers/machine/particle-argon.md
+++ /dev/null
@@ -1,1363 +0,0 @@
-
----
-title: particle-argon
----
-
-
-## Constants
-
-```go
-const HasLowFrequencyCrystal = true
-```
-
-
-
-```go
-const (
-	LED		Pin	= 44
-	LED_GREEN	Pin	= 14
-	LED_RED		Pin	= 13
-	LED_BLUE	Pin	= 15
-)
-```
-
-LEDs
-
-
-```go
-const (
-	A0	Pin	= 3
-	A1	Pin	= 4
-	A2	Pin	= 28
-	A3	Pin	= 29
-	A4	Pin	= 30
-	A5	Pin	= 31
-	D0	Pin	= 26	// Also SDA
-	D1	Pin	= 27	// Also SCL
-	D2	Pin	= 33
-	D3	Pin	= 34
-	D4	Pin	= 40
-	D5	Pin	= 42
-	D6	Pin	= 43
-	D7	Pin	= 44	// Also LED
-	D8	Pin	= 35
-	D9	Pin	= 6	// Also TX
-	D10	Pin	= 8	// Also RX
-	D11	Pin	= 46	// Also SDI
-	D12	Pin	= 45	// Also SDO
-	D13	Pin	= 47	// Also SCK
-)
-```
-
-GPIOs
-
-
-```go
-const (
-	UART_TX_PIN	Pin	= 6
-	UART_RX_PIN	Pin	= 8
-)
-```
-
-
-
-```go
-const (
-	SDA_PIN	Pin	= 26
-	SCL_PIN	Pin	= 27
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	Pin	= 47
-	SPI0_SDO_PIN	Pin	= 45
-	SPI0_SDI_PIN	Pin	= 46
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	SPI1_SCK_PIN	Pin	= 19
-	SPI1_SDO_PIN	Pin	= 20
-	SPI1_SDI_PIN	Pin	= 21
-	SPI1_CS_PIN	Pin	= 17
-	SPI1_WP_PIN	Pin	= 22
-	SPI1_HOLD_PIN	Pin	= 23
-)
-```
-
-Internal 4MB SPI Flash
-
-
-```go
-const (
-	ESP32_TXD_PIN		Pin	= 36
-	ESP32_RXD_PIN		Pin	= 37
-	ESP32_CTS_PIN		Pin	= 39
-	ESP32_RTS_PIN		Pin	= 38
-	ESP32_BOOT_MODE_PIN	Pin	= 16
-	ESP32_WIFI_EN_PIN	Pin	= 24
-	ESP32_HOST_WK_PIN	Pin	= 7
-)
-```
-
-ESP32 coprocessor
-
-
-```go
-const (
-	MODE_BUTTON_PIN		Pin	= 11
-	CHARGE_STATUS_PIN	Pin	= 41
-	LIPO_VOLTAGE_PIN	Pin	= 5
-	PCB_ANTENNA_PIN		Pin	= 2
-	EXTERNAL_UFL_PIN	Pin	= 25
-	NFC1_PIN		Pin	= 9
-	NFC2_PIN		Pin	= 10
-)
-```
-
-Other peripherals
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Disconnect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
-	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
-	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	P0_00	Pin	= 0
-	P0_01	Pin	= 1
-	P0_02	Pin	= 2
-	P0_03	Pin	= 3
-	P0_04	Pin	= 4
-	P0_05	Pin	= 5
-	P0_06	Pin	= 6
-	P0_07	Pin	= 7
-	P0_08	Pin	= 8
-	P0_09	Pin	= 9
-	P0_10	Pin	= 10
-	P0_11	Pin	= 11
-	P0_12	Pin	= 12
-	P0_13	Pin	= 13
-	P0_14	Pin	= 14
-	P0_15	Pin	= 15
-	P0_16	Pin	= 16
-	P0_17	Pin	= 17
-	P0_18	Pin	= 18
-	P0_19	Pin	= 19
-	P0_20	Pin	= 20
-	P0_21	Pin	= 21
-	P0_22	Pin	= 22
-	P0_23	Pin	= 23
-	P0_24	Pin	= 24
-	P0_25	Pin	= 25
-	P0_26	Pin	= 26
-	P0_27	Pin	= 27
-	P0_28	Pin	= 28
-	P0_29	Pin	= 29
-	P0_30	Pin	= 30
-	P0_31	Pin	= 31
-	P1_00	Pin	= 32
-	P1_01	Pin	= 33
-	P1_02	Pin	= 34
-	P1_03	Pin	= 35
-	P1_04	Pin	= 36
-	P1_05	Pin	= 37
-	P1_06	Pin	= 38
-	P1_07	Pin	= 39
-	P1_08	Pin	= 40
-	P1_09	Pin	= 41
-	P1_10	Pin	= 42
-	P1_11	Pin	= 43
-	P1_12	Pin	= 44
-	P1_13	Pin	= 45
-	P1_14	Pin	= 46
-	P1_15	Pin	= 47
-)
-```
-
-Hardware pins
-
-
-
-
-
-## Variables
-
-```go
-var (
-	Serial	= USB
-	UART0	= NRF_UART0
-)
-```
-
-UART
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-```go
-var (
-	// NRF_UART0 is the hardware UART on the NRF SoC.
-	NRF_UART0 = UART{Buffer: NewRingBuffer()}
-)
-```
-
-UART
-
-
-```go
-var (
-	I2C0	= I2C{Bus: nrf.TWI0}
-	I2C1	= I2C{Bus: nrf.TWI1}
-)
-```
-
-There are 2 I2C interfaces on the NRF.
-
-
-```go
-var (
-	SPI0	= SPI{Bus: nrf.SPI0}
-	SPI1	= SPI{Bus: nrf.SPI1}
-)
-```
-
-There are 2 SPI interfaces on the NRF5x.
-
-
-```go
-var (
-	USB	= USBCDC{Buffer: NewRingBuffer()}
-
-	usbEndpointDescriptors	[8]usbDeviceDescriptor
-
-	udd_ep_in_cache_buffer	[7][128]uint8
-	udd_ep_out_cache_buffer	[7][128]uint8
-
-	sendOnEP0DATADONE	struct {
-		ptr	*byte
-		count	int
-	}
-	isEndpointHalt		= false
-	isRemoteWakeUpEnabled	= false
-	endPoints		= []uint32{usb_ENDPOINT_TYPE_CONTROL,
-		(usb_ENDPOINT_TYPE_INTERRUPT | usbEndpointIn),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointOut),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointIn)}
-
-	usbConfiguration		uint8
-	usbSetInterface			uint8
-	usbLineInfo			= cdcLineInfo{115200, 0x00, 0x00, 0x08, 0x00}
-	epinen				uint32
-	epouten				uint32
-	easyDMABusy			volatile.Register8
-	epout0data_setlinecoding	bool
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the registers needed for ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the registers needed for PWM.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure() error
-```
-
-Configure configures an ADC pin to be able to read analog data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus *nrf.TWI_Type
-}
-```
-
-I2C on the NRF.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) (err error)
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure()
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *nrf.SPI_Type
-}
-```
-
-SPI on the NRF.
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the NRF.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer		*RingBuffer
-	interrupt	interrupt.Interrupt
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the nRF52840
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (*USBCDC) Configure
-
-```go
-func (usbcdc *USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/particle-boron.md b/content/microcontrollers/machine/particle-boron.md
deleted file mode 100644
index 56174049..00000000
--- a/content/microcontrollers/machine/particle-boron.md
+++ /dev/null
@@ -1,1366 +0,0 @@
-
----
-title: particle-boron
----
-
-
-## Constants
-
-```go
-const HasLowFrequencyCrystal = true
-```
-
-
-
-```go
-const (
-	LED		Pin	= 44
-	LED_GREEN	Pin	= 14
-	LED_RED		Pin	= 13
-	LED_BLUE	Pin	= 15
-)
-```
-
-LEDs
-
-
-```go
-const (
-	A0	Pin	= 3
-	A1	Pin	= 4
-	A2	Pin	= 28
-	A3	Pin	= 29
-	A4	Pin	= 30
-	A5	Pin	= 31
-	D0	Pin	= 26	// Also SDA
-	D1	Pin	= 27	// Also SCL
-	D2	Pin	= 33
-	D3	Pin	= 34
-	D4	Pin	= 40
-	D5	Pin	= 42
-	D6	Pin	= 43
-	D7	Pin	= 44	// Also LED
-	D8	Pin	= 35
-	D9	Pin	= 6	// Also TX
-	D10	Pin	= 8	// Also RX
-	D11	Pin	= 46	// Also SDI
-	D12	Pin	= 45	// Also SDO
-	D13	Pin	= 47	// Also SCK
-)
-```
-
-GPIOs
-
-
-```go
-const (
-	UART_TX_PIN	Pin	= 6
-	UART_RX_PIN	Pin	= 8
-)
-```
-
-
-
-```go
-const (
-	SDA_PIN	Pin	= 26
-	SCL_PIN	Pin	= 27
-
-	// Internal I2C with MAX17043 (Fuel gauge) and BQ24195 (Power management) chips on it
-	SDA1_PIN	Pin	= 24
-	SCL1_PIN	Pin	= 41
-	INT1_PIN	Pin	= 5
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	Pin	= 47
-	SPI0_SDO_PIN	Pin	= 45
-	SPI0_SDI_PIN	Pin	= 46
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	SPI1_SCK_PIN	Pin	= 19
-	SPI1_SDO_PIN	Pin	= 20
-	SPI1_SDI_PIN	Pin	= 21
-	SPI1_CS_PIN	Pin	= 17
-	SPI1_WP_PIN	Pin	= 22
-	SPI1_HOLD_PIN	Pin	= 23
-)
-```
-
-Internal 4MB SPI Flash
-
-
-```go
-const (
-	SARA_TXD_PIN		Pin	= 37
-	SARA_RXD_PIN		Pin	= 36
-	SARA_CTS_PIN		Pin	= 38
-	SARA_RTS_PIN		Pin	= 39
-	SARA_RESET_PIN		Pin	= 12
-	SARA_POWER_ON_PIN	Pin	= 16
-	SARA_BUFF_EN_PIN	Pin	= 25
-	SARA_VINT_PIN		Pin	= 2
-)
-```
-
-u-blox SARA coprocessor
-
-
-```go
-const (
-	MODE_BUTTON_PIN	Pin	= 11
-	ANTENNA_SEL_PIN	Pin	= 7	// Low: chip antenna, High: External uFL
-	NFC1_PIN	Pin	= 9
-	NFC2_PIN	Pin	= 10
-)
-```
-
-Other peripherals
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Disconnect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
-	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
-	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	P0_00	Pin	= 0
-	P0_01	Pin	= 1
-	P0_02	Pin	= 2
-	P0_03	Pin	= 3
-	P0_04	Pin	= 4
-	P0_05	Pin	= 5
-	P0_06	Pin	= 6
-	P0_07	Pin	= 7
-	P0_08	Pin	= 8
-	P0_09	Pin	= 9
-	P0_10	Pin	= 10
-	P0_11	Pin	= 11
-	P0_12	Pin	= 12
-	P0_13	Pin	= 13
-	P0_14	Pin	= 14
-	P0_15	Pin	= 15
-	P0_16	Pin	= 16
-	P0_17	Pin	= 17
-	P0_18	Pin	= 18
-	P0_19	Pin	= 19
-	P0_20	Pin	= 20
-	P0_21	Pin	= 21
-	P0_22	Pin	= 22
-	P0_23	Pin	= 23
-	P0_24	Pin	= 24
-	P0_25	Pin	= 25
-	P0_26	Pin	= 26
-	P0_27	Pin	= 27
-	P0_28	Pin	= 28
-	P0_29	Pin	= 29
-	P0_30	Pin	= 30
-	P0_31	Pin	= 31
-	P1_00	Pin	= 32
-	P1_01	Pin	= 33
-	P1_02	Pin	= 34
-	P1_03	Pin	= 35
-	P1_04	Pin	= 36
-	P1_05	Pin	= 37
-	P1_06	Pin	= 38
-	P1_07	Pin	= 39
-	P1_08	Pin	= 40
-	P1_09	Pin	= 41
-	P1_10	Pin	= 42
-	P1_11	Pin	= 43
-	P1_12	Pin	= 44
-	P1_13	Pin	= 45
-	P1_14	Pin	= 46
-	P1_15	Pin	= 47
-)
-```
-
-Hardware pins
-
-
-
-
-
-## Variables
-
-```go
-var (
-	Serial	= USB
-	UART0	= NRF_UART0
-)
-```
-
-UART
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-```go
-var (
-	// NRF_UART0 is the hardware UART on the NRF SoC.
-	NRF_UART0 = UART{Buffer: NewRingBuffer()}
-)
-```
-
-UART
-
-
-```go
-var (
-	I2C0	= I2C{Bus: nrf.TWI0}
-	I2C1	= I2C{Bus: nrf.TWI1}
-)
-```
-
-There are 2 I2C interfaces on the NRF.
-
-
-```go
-var (
-	SPI0	= SPI{Bus: nrf.SPI0}
-	SPI1	= SPI{Bus: nrf.SPI1}
-)
-```
-
-There are 2 SPI interfaces on the NRF5x.
-
-
-```go
-var (
-	USB	= USBCDC{Buffer: NewRingBuffer()}
-
-	usbEndpointDescriptors	[8]usbDeviceDescriptor
-
-	udd_ep_in_cache_buffer	[7][128]uint8
-	udd_ep_out_cache_buffer	[7][128]uint8
-
-	sendOnEP0DATADONE	struct {
-		ptr	*byte
-		count	int
-	}
-	isEndpointHalt		= false
-	isRemoteWakeUpEnabled	= false
-	endPoints		= []uint32{usb_ENDPOINT_TYPE_CONTROL,
-		(usb_ENDPOINT_TYPE_INTERRUPT | usbEndpointIn),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointOut),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointIn)}
-
-	usbConfiguration		uint8
-	usbSetInterface			uint8
-	usbLineInfo			= cdcLineInfo{115200, 0x00, 0x00, 0x08, 0x00}
-	epinen				uint32
-	epouten				uint32
-	easyDMABusy			volatile.Register8
-	epout0data_setlinecoding	bool
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the registers needed for ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the registers needed for PWM.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure() error
-```
-
-Configure configures an ADC pin to be able to read analog data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus *nrf.TWI_Type
-}
-```
-
-I2C on the NRF.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) (err error)
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure()
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *nrf.SPI_Type
-}
-```
-
-SPI on the NRF.
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the NRF.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer		*RingBuffer
-	interrupt	interrupt.Interrupt
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the nRF52840
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (*USBCDC) Configure
-
-```go
-func (usbcdc *USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/particle-xenon.md b/content/microcontrollers/machine/particle-xenon.md
deleted file mode 100644
index d6984a58..00000000
--- a/content/microcontrollers/machine/particle-xenon.md
+++ /dev/null
@@ -1,1348 +0,0 @@
-
----
-title: particle-xenon
----
-
-
-## Constants
-
-```go
-const HasLowFrequencyCrystal = true
-```
-
-
-
-```go
-const (
-	LED		Pin	= 44
-	LED_GREEN	Pin	= 14
-	LED_RED		Pin	= 13
-	LED_BLUE	Pin	= 15
-)
-```
-
-LEDs
-
-
-```go
-const (
-	A0	Pin	= 3
-	A1	Pin	= 4
-	A2	Pin	= 28
-	A3	Pin	= 29
-	A4	Pin	= 30
-	A5	Pin	= 31
-	D0	Pin	= 26	// Also SDA
-	D1	Pin	= 27	// Also SCL
-	D2	Pin	= 33
-	D3	Pin	= 34
-	D4	Pin	= 40
-	D5	Pin	= 42
-	D6	Pin	= 43
-	D7	Pin	= 44	// Also LED
-	D8	Pin	= 35
-	D9	Pin	= 6	// Also TX
-	D10	Pin	= 8	// Also RX
-	D11	Pin	= 46	// Also SDI
-	D12	Pin	= 45	// Also SDO
-	D13	Pin	= 47	// Also SCK
-)
-```
-
-GPIOs
-
-
-```go
-const (
-	UART_TX_PIN	Pin	= 6
-	UART_RX_PIN	Pin	= 8
-)
-```
-
-
-
-```go
-const (
-	SDA_PIN	Pin	= 26
-	SCL_PIN	Pin	= 27
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	Pin	= 47
-	SPI0_SDO_PIN	Pin	= 45
-	SPI0_SDI_PIN	Pin	= 46
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	SPI1_SCK_PIN	Pin	= 19
-	SPI1_SDO_PIN	Pin	= 20
-	SPI1_SDI_PIN	Pin	= 21
-	SPI1_CS_PIN	Pin	= 17
-	SPI1_WP_PIN	Pin	= 22
-	SPI1_HOLD_PIN	Pin	= 23
-)
-```
-
-Internal 4MB SPI Flash
-
-
-```go
-const (
-	MODE_BUTTON_PIN		Pin	= 11
-	CHARGE_STATUS_PIN	Pin	= 41
-	LIPO_VOLTAGE_PIN	Pin	= 5
-	PCB_ANTENNA_PIN		Pin	= 24
-	EXTERNAL_UFL_PIN	Pin	= 25
-	NFC1_PIN		Pin	= 9
-	NFC2_PIN		Pin	= 10
-)
-```
-
-Other peripherals
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Disconnect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
-	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
-	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	P0_00	Pin	= 0
-	P0_01	Pin	= 1
-	P0_02	Pin	= 2
-	P0_03	Pin	= 3
-	P0_04	Pin	= 4
-	P0_05	Pin	= 5
-	P0_06	Pin	= 6
-	P0_07	Pin	= 7
-	P0_08	Pin	= 8
-	P0_09	Pin	= 9
-	P0_10	Pin	= 10
-	P0_11	Pin	= 11
-	P0_12	Pin	= 12
-	P0_13	Pin	= 13
-	P0_14	Pin	= 14
-	P0_15	Pin	= 15
-	P0_16	Pin	= 16
-	P0_17	Pin	= 17
-	P0_18	Pin	= 18
-	P0_19	Pin	= 19
-	P0_20	Pin	= 20
-	P0_21	Pin	= 21
-	P0_22	Pin	= 22
-	P0_23	Pin	= 23
-	P0_24	Pin	= 24
-	P0_25	Pin	= 25
-	P0_26	Pin	= 26
-	P0_27	Pin	= 27
-	P0_28	Pin	= 28
-	P0_29	Pin	= 29
-	P0_30	Pin	= 30
-	P0_31	Pin	= 31
-	P1_00	Pin	= 32
-	P1_01	Pin	= 33
-	P1_02	Pin	= 34
-	P1_03	Pin	= 35
-	P1_04	Pin	= 36
-	P1_05	Pin	= 37
-	P1_06	Pin	= 38
-	P1_07	Pin	= 39
-	P1_08	Pin	= 40
-	P1_09	Pin	= 41
-	P1_10	Pin	= 42
-	P1_11	Pin	= 43
-	P1_12	Pin	= 44
-	P1_13	Pin	= 45
-	P1_14	Pin	= 46
-	P1_15	Pin	= 47
-)
-```
-
-Hardware pins
-
-
-
-
-
-## Variables
-
-```go
-var (
-	Serial	= USB
-	UART0	= NRF_UART0
-)
-```
-
-UART
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-```go
-var (
-	// NRF_UART0 is the hardware UART on the NRF SoC.
-	NRF_UART0 = UART{Buffer: NewRingBuffer()}
-)
-```
-
-UART
-
-
-```go
-var (
-	I2C0	= I2C{Bus: nrf.TWI0}
-	I2C1	= I2C{Bus: nrf.TWI1}
-)
-```
-
-There are 2 I2C interfaces on the NRF.
-
-
-```go
-var (
-	SPI0	= SPI{Bus: nrf.SPI0}
-	SPI1	= SPI{Bus: nrf.SPI1}
-)
-```
-
-There are 2 SPI interfaces on the NRF5x.
-
-
-```go
-var (
-	USB	= USBCDC{Buffer: NewRingBuffer()}
-
-	usbEndpointDescriptors	[8]usbDeviceDescriptor
-
-	udd_ep_in_cache_buffer	[7][128]uint8
-	udd_ep_out_cache_buffer	[7][128]uint8
-
-	sendOnEP0DATADONE	struct {
-		ptr	*byte
-		count	int
-	}
-	isEndpointHalt		= false
-	isRemoteWakeUpEnabled	= false
-	endPoints		= []uint32{usb_ENDPOINT_TYPE_CONTROL,
-		(usb_ENDPOINT_TYPE_INTERRUPT | usbEndpointIn),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointOut),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointIn)}
-
-	usbConfiguration		uint8
-	usbSetInterface			uint8
-	usbLineInfo			= cdcLineInfo{115200, 0x00, 0x00, 0x08, 0x00}
-	epinen				uint32
-	epouten				uint32
-	easyDMABusy			volatile.Register8
-	epout0data_setlinecoding	bool
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the registers needed for ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the registers needed for PWM.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure() error
-```
-
-Configure configures an ADC pin to be able to read analog data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus *nrf.TWI_Type
-}
-```
-
-I2C on the NRF.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) (err error)
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure()
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *nrf.SPI_Type
-}
-```
-
-SPI on the NRF.
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the NRF.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer		*RingBuffer
-	interrupt	interrupt.Interrupt
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the nRF52840
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (*USBCDC) Configure
-
-```go
-func (usbcdc *USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/pca10031.md b/content/microcontrollers/machine/pca10031.md
deleted file mode 100644
index 8adb561d..00000000
--- a/content/microcontrollers/machine/pca10031.md
+++ /dev/null
@@ -1,658 +0,0 @@
-
----
-title: pca10031
----
-
-
-## Constants
-
-```go
-const HasLowFrequencyCrystal = true
-```
-
-The pca10031 has a 32kHz crystal on board.
-
-
-```go
-const (
-	LED		Pin	= LED_RED
-	LED1		Pin	= LED_RED
-	LED2		Pin	= LED_GREEN
-	LED3		Pin	= LED_BLUE
-	LED_RED		Pin	= 21
-	LED_GREEN	Pin	= 22
-	LED_BLUE	Pin	= 23
-)
-```
-
-LED on the pca10031
-
-
-```go
-const (
-	UART_TX_PIN	Pin	= 9
-	UART_RX_PIN	Pin	= 11
-)
-```
-
-UART pins
-
-
-```go
-const (
-	SDA_PIN	= NoPin
-	SCL_PIN	= NoPin
-)
-```
-
-I2C pins (disabled)
-
-
-```go
-const (
-	SPI0_SCK_PIN	= NoPin
-	SPI0_SDO_PIN	= NoPin
-	SPI0_SDI_PIN	= NoPin
-)
-```
-
-SPI pins (unused)
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Disconnect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
-	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
-	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-
-
-
-## Variables
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-```go
-var (
-	// NRF_UART0 is the hardware UART on the NRF SoC.
-	NRF_UART0 = UART{Buffer: NewRingBuffer()}
-)
-```
-
-UART
-
-
-```go
-var (
-	I2C0	= I2C{Bus: nrf.TWI0}
-	I2C1	= I2C{Bus: nrf.TWI1}
-)
-```
-
-There are 2 I2C interfaces on the NRF.
-
-
-```go
-var (
-	SPI0	= SPI{Bus: nrf.SPI0}
-	SPI1	= SPI{Bus: nrf.SPI1}
-)
-```
-
-There are 2 SPI interfaces on the NRF5x.
-
-
-```go
-var (
-	UART0 = NRF_UART0
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus *nrf.TWI_Type
-}
-```
-
-I2C on the NRF.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) (err error)
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *nrf.SPI_Type
-}
-```
-
-SPI on the NRF.
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the NRF.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/pca10040-s132v6.md b/content/microcontrollers/machine/pca10040-s132v6.md
deleted file mode 100644
index 32ac628e..00000000
--- a/content/microcontrollers/machine/pca10040-s132v6.md
+++ /dev/null
@@ -1,737 +0,0 @@
-
----
-title: pca10040-s132v6
----
-
-
-## Constants
-
-```go
-const HasLowFrequencyCrystal = true
-```
-
-The PCA10040 has a low-frequency (32kHz) crystal oscillator on board.
-
-
-```go
-const (
-	LED	Pin	= LED1
-	LED1	Pin	= 17
-	LED2	Pin	= 18
-	LED3	Pin	= 19
-	LED4	Pin	= 20
-)
-```
-
-LEDs on the PCA10040 (nRF52832 dev board)
-
-
-```go
-const (
-	BUTTON	Pin	= BUTTON1
-	BUTTON1	Pin	= 13
-	BUTTON2	Pin	= 14
-	BUTTON3	Pin	= 15
-	BUTTON4	Pin	= 16
-)
-```
-
-Buttons on the PCA10040 (nRF52832 dev board)
-
-
-```go
-const (
-	UART_TX_PIN	Pin	= 6
-	UART_RX_PIN	Pin	= 8
-)
-```
-
-UART pins for NRF52840-DK
-
-
-```go
-const (
-	ADC0	Pin	= 3
-	ADC1	Pin	= 4
-	ADC2	Pin	= 28
-	ADC3	Pin	= 29
-	ADC4	Pin	= 30
-	ADC5	Pin	= 31
-)
-```
-
-ADC pins
-
-
-```go
-const (
-	SDA_PIN	Pin	= 26
-	SCL_PIN	Pin	= 27
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	Pin	= 25
-	SPI0_SDO_PIN	Pin	= 23
-	SPI0_SDI_PIN	Pin	= 24
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Disconnect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
-	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
-	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-
-
-
-## Variables
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-```go
-var (
-	// NRF_UART0 is the hardware UART on the NRF SoC.
-	NRF_UART0 = UART{Buffer: NewRingBuffer()}
-)
-```
-
-UART
-
-
-```go
-var (
-	I2C0	= I2C{Bus: nrf.TWI0}
-	I2C1	= I2C{Bus: nrf.TWI1}
-)
-```
-
-There are 2 I2C interfaces on the NRF.
-
-
-```go
-var (
-	SPI0	= SPI{Bus: nrf.SPI0}
-	SPI1	= SPI{Bus: nrf.SPI1}
-)
-```
-
-There are 2 SPI interfaces on the NRF5x.
-
-
-```go
-var (
-	UART0 = NRF_UART0
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the registers needed for ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the registers needed for PWM.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure()
-```
-
-Configure configures an ADC pin to be able to read analog data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin in the range 0..0xffff.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus *nrf.TWI_Type
-}
-```
-
-I2C on the NRF.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) (err error)
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure() error
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *nrf.SPI_Type
-}
-```
-
-SPI on the NRF.
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the NRF.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/pca10040.md b/content/microcontrollers/machine/pca10040.md
deleted file mode 100644
index d9cc6aa8..00000000
--- a/content/microcontrollers/machine/pca10040.md
+++ /dev/null
@@ -1,737 +0,0 @@
-
----
-title: pca10040
----
-
-
-## Constants
-
-```go
-const HasLowFrequencyCrystal = true
-```
-
-The PCA10040 has a low-frequency (32kHz) crystal oscillator on board.
-
-
-```go
-const (
-	LED	Pin	= LED1
-	LED1	Pin	= 17
-	LED2	Pin	= 18
-	LED3	Pin	= 19
-	LED4	Pin	= 20
-)
-```
-
-LEDs on the PCA10040 (nRF52832 dev board)
-
-
-```go
-const (
-	BUTTON	Pin	= BUTTON1
-	BUTTON1	Pin	= 13
-	BUTTON2	Pin	= 14
-	BUTTON3	Pin	= 15
-	BUTTON4	Pin	= 16
-)
-```
-
-Buttons on the PCA10040 (nRF52832 dev board)
-
-
-```go
-const (
-	UART_TX_PIN	Pin	= 6
-	UART_RX_PIN	Pin	= 8
-)
-```
-
-UART pins for NRF52840-DK
-
-
-```go
-const (
-	ADC0	Pin	= 3
-	ADC1	Pin	= 4
-	ADC2	Pin	= 28
-	ADC3	Pin	= 29
-	ADC4	Pin	= 30
-	ADC5	Pin	= 31
-)
-```
-
-ADC pins
-
-
-```go
-const (
-	SDA_PIN	Pin	= 26
-	SCL_PIN	Pin	= 27
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	Pin	= 25
-	SPI0_SDO_PIN	Pin	= 23
-	SPI0_SDI_PIN	Pin	= 24
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Disconnect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
-	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
-	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-
-
-
-## Variables
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-```go
-var (
-	// NRF_UART0 is the hardware UART on the NRF SoC.
-	NRF_UART0 = UART{Buffer: NewRingBuffer()}
-)
-```
-
-UART
-
-
-```go
-var (
-	I2C0	= I2C{Bus: nrf.TWI0}
-	I2C1	= I2C{Bus: nrf.TWI1}
-)
-```
-
-There are 2 I2C interfaces on the NRF.
-
-
-```go
-var (
-	SPI0	= SPI{Bus: nrf.SPI0}
-	SPI1	= SPI{Bus: nrf.SPI1}
-)
-```
-
-There are 2 SPI interfaces on the NRF5x.
-
-
-```go
-var (
-	UART0 = NRF_UART0
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the registers needed for ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the registers needed for PWM.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure()
-```
-
-Configure configures an ADC pin to be able to read analog data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin in the range 0..0xffff.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus *nrf.TWI_Type
-}
-```
-
-I2C on the NRF.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) (err error)
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure() error
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *nrf.SPI_Type
-}
-```
-
-SPI on the NRF.
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the NRF.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/pca10056-s140v7.md b/content/microcontrollers/machine/pca10056-s140v7.md
deleted file mode 100644
index 07c2fcf0..00000000
--- a/content/microcontrollers/machine/pca10056-s140v7.md
+++ /dev/null
@@ -1,1319 +0,0 @@
-
----
-title: pca10056-s140v7
----
-
-
-## Constants
-
-```go
-const HasLowFrequencyCrystal = true
-```
-
-
-
-```go
-const (
-	LED	Pin	= LED1
-	LED1	Pin	= 13
-	LED2	Pin	= 14
-	LED3	Pin	= 15
-	LED4	Pin	= 16
-)
-```
-
-LEDs on the pca10056
-
-
-```go
-const (
-	BUTTON	Pin	= BUTTON1
-	BUTTON1	Pin	= 11
-	BUTTON2	Pin	= 12
-	BUTTON3	Pin	= 24
-	BUTTON4	Pin	= 25
-)
-```
-
-Buttons on the pca10056
-
-
-```go
-const (
-	UART_TX_PIN	Pin	= 6
-	UART_RX_PIN	Pin	= 8
-)
-```
-
-UART pins
-
-
-```go
-const (
-	ADC0	Pin	= 3
-	ADC1	Pin	= 4
-	ADC2	Pin	= 28
-	ADC3	Pin	= 29
-	ADC4	Pin	= 30
-	ADC5	Pin	= 31
-)
-```
-
-ADC pins
-
-
-```go
-const (
-	SDA_PIN	Pin	= 26	// P0.26
-	SCL_PIN	Pin	= 27	// P0.27
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	Pin	= 47	// P1.15
-	SPI0_SDO_PIN	Pin	= 45	// P1.13
-	SPI0_SDI_PIN	Pin	= 46	// P1.14
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Disconnect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
-	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
-	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	P0_00	Pin	= 0
-	P0_01	Pin	= 1
-	P0_02	Pin	= 2
-	P0_03	Pin	= 3
-	P0_04	Pin	= 4
-	P0_05	Pin	= 5
-	P0_06	Pin	= 6
-	P0_07	Pin	= 7
-	P0_08	Pin	= 8
-	P0_09	Pin	= 9
-	P0_10	Pin	= 10
-	P0_11	Pin	= 11
-	P0_12	Pin	= 12
-	P0_13	Pin	= 13
-	P0_14	Pin	= 14
-	P0_15	Pin	= 15
-	P0_16	Pin	= 16
-	P0_17	Pin	= 17
-	P0_18	Pin	= 18
-	P0_19	Pin	= 19
-	P0_20	Pin	= 20
-	P0_21	Pin	= 21
-	P0_22	Pin	= 22
-	P0_23	Pin	= 23
-	P0_24	Pin	= 24
-	P0_25	Pin	= 25
-	P0_26	Pin	= 26
-	P0_27	Pin	= 27
-	P0_28	Pin	= 28
-	P0_29	Pin	= 29
-	P0_30	Pin	= 30
-	P0_31	Pin	= 31
-	P1_00	Pin	= 32
-	P1_01	Pin	= 33
-	P1_02	Pin	= 34
-	P1_03	Pin	= 35
-	P1_04	Pin	= 36
-	P1_05	Pin	= 37
-	P1_06	Pin	= 38
-	P1_07	Pin	= 39
-	P1_08	Pin	= 40
-	P1_09	Pin	= 41
-	P1_10	Pin	= 42
-	P1_11	Pin	= 43
-	P1_12	Pin	= 44
-	P1_13	Pin	= 45
-	P1_14	Pin	= 46
-	P1_15	Pin	= 47
-)
-```
-
-Hardware pins
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART0 = NRF_UART0
-)
-```
-
-UART0 is the NRF UART
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-```go
-var (
-	// NRF_UART0 is the hardware UART on the NRF SoC.
-	NRF_UART0 = UART{Buffer: NewRingBuffer()}
-)
-```
-
-UART
-
-
-```go
-var (
-	I2C0	= I2C{Bus: nrf.TWI0}
-	I2C1	= I2C{Bus: nrf.TWI1}
-)
-```
-
-There are 2 I2C interfaces on the NRF.
-
-
-```go
-var (
-	SPI0	= SPI{Bus: nrf.SPI0}
-	SPI1	= SPI{Bus: nrf.SPI1}
-)
-```
-
-There are 2 SPI interfaces on the NRF5x.
-
-
-```go
-var (
-	USB	= USBCDC{Buffer: NewRingBuffer()}
-
-	usbEndpointDescriptors	[8]usbDeviceDescriptor
-
-	udd_ep_in_cache_buffer	[7][128]uint8
-	udd_ep_out_cache_buffer	[7][128]uint8
-
-	sendOnEP0DATADONE	struct {
-		ptr	*byte
-		count	int
-	}
-	isEndpointHalt		= false
-	isRemoteWakeUpEnabled	= false
-	endPoints		= []uint32{usb_ENDPOINT_TYPE_CONTROL,
-		(usb_ENDPOINT_TYPE_INTERRUPT | usbEndpointIn),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointOut),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointIn)}
-
-	usbConfiguration		uint8
-	usbSetInterface			uint8
-	usbLineInfo			= cdcLineInfo{115200, 0x00, 0x00, 0x08, 0x00}
-	epinen				uint32
-	epouten				uint32
-	easyDMABusy			volatile.Register8
-	epout0data_setlinecoding	bool
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the registers needed for ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the registers needed for PWM.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure() error
-```
-
-Configure configures an ADC pin to be able to read analog data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus *nrf.TWI_Type
-}
-```
-
-I2C on the NRF.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) (err error)
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure()
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *nrf.SPI_Type
-}
-```
-
-SPI on the NRF.
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the NRF.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer		*RingBuffer
-	interrupt	interrupt.Interrupt
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the nRF52840
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (*USBCDC) Configure
-
-```go
-func (usbcdc *USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/pca10056.md b/content/microcontrollers/machine/pca10056.md
deleted file mode 100644
index 18800c4a..00000000
--- a/content/microcontrollers/machine/pca10056.md
+++ /dev/null
@@ -1,1319 +0,0 @@
-
----
-title: pca10056
----
-
-
-## Constants
-
-```go
-const HasLowFrequencyCrystal = true
-```
-
-
-
-```go
-const (
-	LED	Pin	= LED1
-	LED1	Pin	= 13
-	LED2	Pin	= 14
-	LED3	Pin	= 15
-	LED4	Pin	= 16
-)
-```
-
-LEDs on the pca10056
-
-
-```go
-const (
-	BUTTON	Pin	= BUTTON1
-	BUTTON1	Pin	= 11
-	BUTTON2	Pin	= 12
-	BUTTON3	Pin	= 24
-	BUTTON4	Pin	= 25
-)
-```
-
-Buttons on the pca10056
-
-
-```go
-const (
-	UART_TX_PIN	Pin	= 6
-	UART_RX_PIN	Pin	= 8
-)
-```
-
-UART pins
-
-
-```go
-const (
-	ADC0	Pin	= 3
-	ADC1	Pin	= 4
-	ADC2	Pin	= 28
-	ADC3	Pin	= 29
-	ADC4	Pin	= 30
-	ADC5	Pin	= 31
-)
-```
-
-ADC pins
-
-
-```go
-const (
-	SDA_PIN	Pin	= 26	// P0.26
-	SCL_PIN	Pin	= 27	// P0.27
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	Pin	= 47	// P1.15
-	SPI0_SDO_PIN	Pin	= 45	// P1.13
-	SPI0_SDI_PIN	Pin	= 46	// P1.14
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Disconnect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
-	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
-	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	P0_00	Pin	= 0
-	P0_01	Pin	= 1
-	P0_02	Pin	= 2
-	P0_03	Pin	= 3
-	P0_04	Pin	= 4
-	P0_05	Pin	= 5
-	P0_06	Pin	= 6
-	P0_07	Pin	= 7
-	P0_08	Pin	= 8
-	P0_09	Pin	= 9
-	P0_10	Pin	= 10
-	P0_11	Pin	= 11
-	P0_12	Pin	= 12
-	P0_13	Pin	= 13
-	P0_14	Pin	= 14
-	P0_15	Pin	= 15
-	P0_16	Pin	= 16
-	P0_17	Pin	= 17
-	P0_18	Pin	= 18
-	P0_19	Pin	= 19
-	P0_20	Pin	= 20
-	P0_21	Pin	= 21
-	P0_22	Pin	= 22
-	P0_23	Pin	= 23
-	P0_24	Pin	= 24
-	P0_25	Pin	= 25
-	P0_26	Pin	= 26
-	P0_27	Pin	= 27
-	P0_28	Pin	= 28
-	P0_29	Pin	= 29
-	P0_30	Pin	= 30
-	P0_31	Pin	= 31
-	P1_00	Pin	= 32
-	P1_01	Pin	= 33
-	P1_02	Pin	= 34
-	P1_03	Pin	= 35
-	P1_04	Pin	= 36
-	P1_05	Pin	= 37
-	P1_06	Pin	= 38
-	P1_07	Pin	= 39
-	P1_08	Pin	= 40
-	P1_09	Pin	= 41
-	P1_10	Pin	= 42
-	P1_11	Pin	= 43
-	P1_12	Pin	= 44
-	P1_13	Pin	= 45
-	P1_14	Pin	= 46
-	P1_15	Pin	= 47
-)
-```
-
-Hardware pins
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART0 = NRF_UART0
-)
-```
-
-UART0 is the NRF UART
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-```go
-var (
-	// NRF_UART0 is the hardware UART on the NRF SoC.
-	NRF_UART0 = UART{Buffer: NewRingBuffer()}
-)
-```
-
-UART
-
-
-```go
-var (
-	I2C0	= I2C{Bus: nrf.TWI0}
-	I2C1	= I2C{Bus: nrf.TWI1}
-)
-```
-
-There are 2 I2C interfaces on the NRF.
-
-
-```go
-var (
-	SPI0	= SPI{Bus: nrf.SPI0}
-	SPI1	= SPI{Bus: nrf.SPI1}
-)
-```
-
-There are 2 SPI interfaces on the NRF5x.
-
-
-```go
-var (
-	USB	= USBCDC{Buffer: NewRingBuffer()}
-
-	usbEndpointDescriptors	[8]usbDeviceDescriptor
-
-	udd_ep_in_cache_buffer	[7][128]uint8
-	udd_ep_out_cache_buffer	[7][128]uint8
-
-	sendOnEP0DATADONE	struct {
-		ptr	*byte
-		count	int
-	}
-	isEndpointHalt		= false
-	isRemoteWakeUpEnabled	= false
-	endPoints		= []uint32{usb_ENDPOINT_TYPE_CONTROL,
-		(usb_ENDPOINT_TYPE_INTERRUPT | usbEndpointIn),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointOut),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointIn)}
-
-	usbConfiguration		uint8
-	usbSetInterface			uint8
-	usbLineInfo			= cdcLineInfo{115200, 0x00, 0x00, 0x08, 0x00}
-	epinen				uint32
-	epouten				uint32
-	easyDMABusy			volatile.Register8
-	epout0data_setlinecoding	bool
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the registers needed for ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the registers needed for PWM.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure() error
-```
-
-Configure configures an ADC pin to be able to read analog data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus *nrf.TWI_Type
-}
-```
-
-I2C on the NRF.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) (err error)
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure()
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *nrf.SPI_Type
-}
-```
-
-SPI on the NRF.
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the NRF.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer		*RingBuffer
-	interrupt	interrupt.Interrupt
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the nRF52840
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (*USBCDC) Configure
-
-```go
-func (usbcdc *USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/pinetime-devkit0.md b/content/microcontrollers/machine/pinetime-devkit0.md
deleted file mode 100644
index 4e4a5d39..00000000
--- a/content/microcontrollers/machine/pinetime-devkit0.md
+++ /dev/null
@@ -1,746 +0,0 @@
-
----
-title: pinetime-devkit0
----
-
-
-## Constants
-
-```go
-const HasLowFrequencyCrystal = true
-```
-
-The PineTime has a low-frequency (32kHz) crystal oscillator on board.
-
-
-```go
-const (
-	LED	= LED1
-	LED1	= LCD_BACKLIGHT_HIGH
-	LED2	= LCD_BACKLIGHT_MID
-	LED3	= LCD_BACKLIGHT_LOW
-)
-```
-
-LEDs simply expose the three brightness level LEDs on the PineTime. They can
-be useful for simple "hello world" style programs.
-
-
-```go
-const (
-	UART_TX_PIN	Pin	= 11	// TP29 (TXD)
-	UART_RX_PIN	Pin	= NoPin
-)
-```
-
-UART pins for PineTime. Note that RX is set to NoPin as RXD is not listed in
-the PineTime schematic 1.0:
-http://files.pine64.org/doc/PineTime/PineTime%20Port%20Assignment%20rev1.0.pdf
-
-
-```go
-const (
-	SPI0_SCK_PIN	Pin	= 2
-	SPI0_SDO_PIN	Pin	= 3
-	SPI0_SDI_PIN	Pin	= 4
-)
-```
-
-SPI pins for the PineTime.
-
-
-```go
-const (
-	SDA_PIN	Pin	= 6
-	SCL_PIN	Pin	= 7
-)
-```
-
-I2C pins for the PineTime.
-
-
-```go
-const (
-	BUTTON_IN	Pin	= 13
-	BUTTON_OUT	Pin	= 15
-)
-```
-
-Button pins. For some reason, there are two pins for the button.
-
-
-```go
-const VIBRATOR_PIN Pin = 16
-```
-
-Pin for the vibrator.
-
-
-```go
-const (
-	LCD_SCK				= SPI0_SCK_PIN
-	LCD_SDI				= SPI0_SDO_PIN
-	LCD_RS			Pin	= 18
-	LCD_CS			Pin	= 25
-	LCD_RESET		Pin	= 26
-	LCD_BACKLIGHT_LOW	Pin	= 14
-	LCD_BACKLIGHT_MID	Pin	= 22
-	LCD_BACKLIGHT_HIGH	Pin	= 23
-)
-```
-
-LCD pins, using the naming convention of the official docs:
-http://files.pine64.org/doc/PineTime/PineTime%20Port%20Assignment%20rev1.0.pdf
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Disconnect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
-	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
-	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-
-
-
-## Variables
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-```go
-var (
-	// NRF_UART0 is the hardware UART on the NRF SoC.
-	NRF_UART0 = UART{Buffer: NewRingBuffer()}
-)
-```
-
-UART
-
-
-```go
-var (
-	I2C0	= I2C{Bus: nrf.TWI0}
-	I2C1	= I2C{Bus: nrf.TWI1}
-)
-```
-
-There are 2 I2C interfaces on the NRF.
-
-
-```go
-var (
-	SPI0	= SPI{Bus: nrf.SPI0}
-	SPI1	= SPI{Bus: nrf.SPI1}
-)
-```
-
-There are 2 SPI interfaces on the NRF5x.
-
-
-```go
-var (
-	UART0 = NRF_UART0
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the registers needed for ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the registers needed for PWM.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure()
-```
-
-Configure configures an ADC pin to be able to read analog data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin in the range 0..0xffff.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus *nrf.TWI_Type
-}
-```
-
-I2C on the NRF.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) (err error)
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure() error
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *nrf.SPI_Type
-}
-```
-
-SPI on the NRF.
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the NRF.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/pybadge.md b/content/microcontrollers/machine/pybadge.md
deleted file mode 100644
index 3dfce486..00000000
--- a/content/microcontrollers/machine/pybadge.md
+++ /dev/null
@@ -1,1736 +0,0 @@
-
----
-title: pybadge
----
-
-
-## Constants
-
-```go
-const RESET_MAGIC_VALUE = 0xf01669ef
-```
-
-used to reset into bootloader
-
-
-```go
-const (
-	D0	= PB17	// UART0 RX/PWM available
-	D1	= PB16	// UART0 TX/PWM available
-	D2	= PB03
-	D3	= PB02
-	D4	= PA14	// PWM available
-	D5	= PA16	// PWM available
-	D6	= PA18	// PWM available
-	D7	= PB14
-	D8	= PA15	// built-in neopixel
-	D9	= PA19	// PWM available
-	D10	= PA20	// can be used for PWM or UART1 TX
-	D11	= PA21	// can be used for PWM or UART1 RX
-	D12	= PA22	// PWM available
-	D13	= PA23	// PWM available
-)
-```
-
-GPIO Pins
-
-
-```go
-const (
-	A0	= PA02	// ADC/AIN[0]
-	A1	= PA05	// ADC/AIN[2]
-	A2	= PB08	// ADC/AIN[3]
-	A3	= PB09	// ADC/AIN[4]
-	A4	= PA04	// ADC/AIN[5]
-	A5	= PA06	// ADC/AIN[6]
-	A6	= PB01	// ADC/AIN[12]/VMEAS
-	A7	= PB04	// ADC/AIN[6]/LIGHT
-	A8	= D2	// ADC/AIN[14]
-	A9	= D3	// ADC/AIN[15]
-)
-```
-
-Analog pins
-
-
-```go
-const (
-	LED		= D13
-	NEOPIXELS	= D8
-
-	LIGHTSENSOR	= A7
-
-	BUTTON_LATCH	= PB00
-	BUTTON_OUT	= PB30
-	BUTTON_CLK	= PB31
-
-	TFT_DC		= PB05
-	TFT_CS		= PB07
-	TFT_RST		= PA00
-	TFT_LITE	= PA01
-
-	SPEAKER_ENABLE	= PA27
-)
-```
-
-
-
-```go
-const (
-	BUTTON_LEFT_MASK	= 1
-	BUTTON_UP_MASK		= 2
-	BUTTON_DOWN_MASK	= 4
-	BUTTON_RIGHT_MASK	= 8
-	BUTTON_SELECT_MASK	= 16
-	BUTTON_START_MASK	= 32
-	BUTTON_A_MASK		= 64
-	BUTTON_B_MASK		= 128
-)
-```
-
-
-
-```go
-const (
-	USBCDC_DM_PIN	= PA24
-	USBCDC_DP_PIN	= PA25
-)
-```
-
-UART0 aka USBCDC pins
-
-
-```go
-const (
-	UART_TX_PIN	= D1
-	UART_RX_PIN	= D0
-)
-```
-
-UART1 pins
-
-
-```go
-const (
-	UART2_TX_PIN	= A4
-	UART2_RX_PIN	= A5
-)
-```
-
-
-
-```go
-const (
-	SDA_PIN	= PA12	// SDA: SERCOM2/PAD[0]
-	SCL_PIN	= PA13	// SCL: SERCOM2/PAD[1]
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	= PA17	// SCK: SERCOM1/PAD[1]
-	SPI0_SDO_PIN	= PB23	// SDO: SERCOM1/PAD[3]
-	SPI0_SDI_PIN	= PB22	// SDI: SERCOM1/PAD[2]
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	SPI1_SCK_PIN	= PB13	// SCK: SERCOM4/PAD[1]
-	SPI1_SDO_PIN	= PB15	// SDO: SERCOM4/PAD[3]
-	SPI1_SDI_PIN	= NoPin
-)
-```
-
-TFT SPI pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const (
-	I2SModeSource	I2SMode	= iota
-	I2SModeReceiver
-	I2SModePDM
-)
-```
-
-
-
-```go
-const (
-	I2StandardPhilips	I2SStandard	= iota
-	I2SStandardMSB
-	I2SStandardLSB
-)
-```
-
-
-
-```go
-const (
-	I2SClockSourceInternal	I2SClockSource	= iota
-	I2SClockSourceExternal
-)
-```
-
-
-
-```go
-const (
-	I2SDataFormatDefault	I2SDataFormat	= 0
-	I2SDataFormat8bit			= 8
-	I2SDataFormat16bit			= 16
-	I2SDataFormat24bit			= 24
-	I2SDataFormat32bit			= 32
-)
-```
-
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinAnalog		PinMode	= 1
-	PinSERCOM		PinMode	= 2
-	PinSERCOMAlt		PinMode	= 3
-	PinTimer		PinMode	= 4
-	PinTimerAlt		PinMode	= 5
-	PinTCCPDEC		PinMode	= 6
-	PinCom			PinMode	= 7
-	PinSDHC			PinMode	= 8
-	PinI2S			PinMode	= 9
-	PinPCC			PinMode	= 10
-	PinGMAC			PinMode	= 11
-	PinACCLK		PinMode	= 12
-	PinCCL			PinMode	= 13
-	PinDigital		PinMode	= 14
-	PinInput		PinMode	= 15
-	PinInputPullup		PinMode	= 16
-	PinOutput		PinMode	= 17
-	PinPWME			PinMode	= PinTimer
-	PinPWMF			PinMode	= PinTimerAlt
-	PinPWMG			PinMode	= PinTCCPDEC
-	PinInputPulldown	PinMode	= 18
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
-	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
-	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	PA00	Pin	= 0
-	PA01	Pin	= 1
-	PA02	Pin	= 2
-	PA03	Pin	= 3
-	PA04	Pin	= 4
-	PA05	Pin	= 5
-	PA06	Pin	= 6
-	PA07	Pin	= 7
-	PA08	Pin	= 8
-	PA09	Pin	= 9
-	PA10	Pin	= 10
-	PA11	Pin	= 11
-	PA12	Pin	= 12
-	PA13	Pin	= 13
-	PA14	Pin	= 14
-	PA15	Pin	= 15
-	PA16	Pin	= 16
-	PA17	Pin	= 17
-	PA18	Pin	= 18
-	PA19	Pin	= 19
-	PA20	Pin	= 20
-	PA21	Pin	= 21
-	PA22	Pin	= 22
-	PA23	Pin	= 23
-	PA24	Pin	= 24
-	PA25	Pin	= 25
-	PA26	Pin	= 26
-	PA27	Pin	= 27
-	PA28	Pin	= 28
-	PA29	Pin	= 29
-	PA30	Pin	= 30
-	PA31	Pin	= 31
-	PB00	Pin	= 32
-	PB01	Pin	= 33
-	PB02	Pin	= 34
-	PB03	Pin	= 35
-	PB04	Pin	= 36
-	PB05	Pin	= 37
-	PB06	Pin	= 38
-	PB07	Pin	= 39
-	PB08	Pin	= 40
-	PB09	Pin	= 41
-	PB10	Pin	= 42
-	PB11	Pin	= 43
-	PB12	Pin	= 44
-	PB13	Pin	= 45
-	PB14	Pin	= 46
-	PB15	Pin	= 47
-	PB16	Pin	= 48
-	PB17	Pin	= 49
-	PB18	Pin	= 50
-	PB19	Pin	= 51
-	PB20	Pin	= 52
-	PB21	Pin	= 53
-	PB22	Pin	= 54
-	PB23	Pin	= 55
-	PB24	Pin	= 56
-	PB25	Pin	= 57
-	PB26	Pin	= 58
-	PB27	Pin	= 59
-	PB28	Pin	= 60
-	PB29	Pin	= 61
-	PB30	Pin	= 62
-	PB31	Pin	= 63
-	PC00	Pin	= 64
-	PC01	Pin	= 65
-	PC02	Pin	= 66
-	PC03	Pin	= 67
-	PC04	Pin	= 68
-	PC05	Pin	= 69
-	PC06	Pin	= 70
-	PC07	Pin	= 71
-	PC08	Pin	= 72
-	PC09	Pin	= 73
-	PC10	Pin	= 74
-	PC11	Pin	= 75
-	PC12	Pin	= 76
-	PC13	Pin	= 77
-	PC14	Pin	= 78
-	PC15	Pin	= 79
-	PC16	Pin	= 80
-	PC17	Pin	= 81
-	PC18	Pin	= 82
-	PC19	Pin	= 83
-	PC20	Pin	= 84
-	PC21	Pin	= 85
-	PC22	Pin	= 86
-	PC23	Pin	= 87
-	PC24	Pin	= 88
-	PC25	Pin	= 89
-	PC26	Pin	= 90
-	PC27	Pin	= 91
-	PC28	Pin	= 92
-	PC29	Pin	= 93
-	PC30	Pin	= 94
-	PC31	Pin	= 95
-	PD00	Pin	= 96
-	PD01	Pin	= 97
-	PD02	Pin	= 98
-	PD03	Pin	= 99
-	PD04	Pin	= 100
-	PD05	Pin	= 101
-	PD06	Pin	= 102
-	PD07	Pin	= 103
-	PD08	Pin	= 104
-	PD09	Pin	= 105
-	PD10	Pin	= 106
-	PD11	Pin	= 107
-	PD12	Pin	= 108
-	PD13	Pin	= 109
-	PD14	Pin	= 110
-	PD15	Pin	= 111
-	PD16	Pin	= 112
-	PD17	Pin	= 113
-	PD18	Pin	= 114
-	PD19	Pin	= 115
-	PD20	Pin	= 116
-	PD21	Pin	= 117
-	PD22	Pin	= 118
-	PD23	Pin	= 119
-	PD24	Pin	= 120
-	PD25	Pin	= 121
-	PD26	Pin	= 122
-	PD27	Pin	= 123
-	PD28	Pin	= 124
-	PD29	Pin	= 125
-	PD30	Pin	= 126
-	PD31	Pin	= 127
-)
-```
-
-Hardware pins
-
-
-```go
-const (
-	// SERCOM_FREQ_REF is always reference frequency on SAMD51 regardless of CPU speed.
-	SERCOM_FREQ_REF	= 48000000
-
-	// Default rise time in nanoseconds, based on 4.7K ohm pull up resistors
-	riseTimeNanoseconds	= 125
-
-	// wire bus states
-	wireUnknownState	= 0
-	wireIdleState		= 1
-	wireOwnerState		= 2
-	wireBusyState		= 3
-
-	// wire commands
-	wireCmdNoAction		= 0
-	wireCmdRepeatStart	= 1
-	wireCmdRead		= 2
-	wireCmdStop		= 3
-)
-```
-
-
-
-```go
-const (
-	QSPI_SCK	= PB10
-	QSPI_CS		= PB11
-	QSPI_DATA0	= PA08
-	QSPI_DATA1	= PA09
-	QSPI_DATA2	= PA10
-	QSPI_DATA3	= PA11
-)
-```
-
-The QSPI peripheral on ATSAMD51 is only available on the following pins
-
-
-```go
-const HSRAM_SIZE = 0x00030000
-```
-
-
-
-```go
-const (
-	Mode0	= 0
-	Mode1	= 1
-	Mode2	= 2
-	Mode3	= 3
-)
-```
-
-SPI phase and polarity configs CPOL and CPHA
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART1	= UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	sam.SERCOM5_USART_INT,
-		SERCOM:	5,
-	}
-
-	UART2	= UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	sam.SERCOM0_USART_INT,
-		SERCOM:	0,
-	}
-)
-```
-
-
-
-```go
-var (
-	I2C0 = I2C{
-		Bus:	sam.SERCOM2_I2CM,
-		SERCOM:	2,
-	}
-)
-```
-
-I2C on the ItsyBitsy M4.
-
-
-```go
-var (
-	SPI0 = SPI{
-		Bus:	sam.SERCOM1_SPIM,
-		SERCOM:	1,
-	}
-)
-```
-
-SPI on the PyBadge.
-
-
-```go
-var (
-	SPI1 = SPI{
-		Bus:	sam.SERCOM4_SPIM,
-		SERCOM:	4,
-	}
-)
-```
-
-TFT SPI on the PyBadge.
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	// UART0 is actually a USB CDC interface.
-	UART0 = USBCDC{Buffer: NewRingBuffer()}
-)
-```
-
-
-
-```go
-var (
-	DAC0 = DAC{}
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the PWM interface.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-### func ResetProcessor
-
-```go
-func ResetProcessor()
-```
-
-ResetProcessor should perform a system reset in preparation
-to switch to the bootloader to flash new firmware.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure()
-```
-
-Configure configures a ADCPin to be able to be used to read data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin, in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DAC
-
-```go
-type DAC struct {
-}
-```
-
-DAC on the SAMD51.
-
-
-
-### func (DAC) Configure
-
-```go
-func (dac DAC) Configure(config DACConfig)
-```
-
-Configure the DAC.
-output pin must already be configured.
-
-
-### func (DAC) Set
-
-```go
-func (dac DAC) Set(value uint16) error
-```
-
-Set writes a single 16-bit value to the DAC.
-Since the ATSAMD51 only has a 12-bit DAC, the passed-in value will be scaled down.
-
-
-
-
-## type DACConfig
-
-```go
-type DACConfig struct {
-}
-```
-
-DACConfig placeholder for future expansion.
-
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus	*sam.SERCOM_I2CM_Type
-	SERCOM	uint8
-}
-```
-
-I2C on the SAMD51.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig) error
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) SetBaudRate
-
-```go
-func (i2c I2C) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the I2C.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteByte
-
-```go
-func (i2c I2C) WriteByte(data byte) error
-```
-
-WriteByte writes a single byte to the I2C bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type I2SClockSource
-
-```go
-type I2SClockSource uint8
-```
-
-
-
-
-
-
-## type I2SConfig
-
-```go
-type I2SConfig struct {
-	SCK		Pin
-	WS		Pin
-	SD		Pin
-	Mode		I2SMode
-	Standard	I2SStandard
-	ClockSource	I2SClockSource
-	DataFormat	I2SDataFormat
-	AudioFrequency	uint32
-	MainClockOutput	bool
-	Stereo		bool
-}
-```
-
-All fields are optional and may not be required or used on a particular platform.
-
-
-
-
-
-## type I2SDataFormat
-
-```go
-type I2SDataFormat uint8
-```
-
-
-
-
-
-
-## type I2SMode
-
-```go
-type I2SMode uint8
-```
-
-
-
-
-
-
-## type I2SStandard
-
-```go
-type I2SStandard uint8
-```
-
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure() error
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-### func (Pin) Toggle
-
-```go
-func (p Pin) Toggle()
-```
-
-Toggle switches an output pin from low to high or from high to low.
-Warning: only use this on an output pin!
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus	*sam.SERCOM_SPIM_Type
-	SERCOM	uint8
-}
-```
-
-SPI
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig) error
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer		*RingBuffer
-	Bus		*sam.SERCOM_USART_INT_Type
-	SERCOM		uint8
-	Interrupt	interrupt.Interrupt	// RXC interrupt
-}
-```
-
-UART on the SAMD51.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig) error
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer *RingBuffer
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the SAMD21.
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (USBCDC) Configure
-
-```go
-func (usbcdc USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/pygamer.md b/content/microcontrollers/machine/pygamer.md
deleted file mode 100644
index 801fd155..00000000
--- a/content/microcontrollers/machine/pygamer.md
+++ /dev/null
@@ -1,1720 +0,0 @@
-
----
-title: pygamer
----
-
-
-## Constants
-
-```go
-const RESET_MAGIC_VALUE = 0xf01669ef
-```
-
-used to reset into bootloader
-
-
-```go
-const (
-	D0	= PB17	// UART0 RX/PWM available
-	D1	= PB16	// UART0 TX/PWM available
-	D2	= PB03
-	D3	= PB02
-	D4	= PA14	// PWM available
-	D5	= PA16	// PWM available
-	D6	= PA18	// PWM available
-	D7	= PB14	// CS for microSD card slot
-	D8	= PA15	// built-in neopixel
-	D9	= PA19	// PWM available
-	D10	= PA20	// can be used for PWM or UART1 TX
-	D11	= PA21	// can be used for PWM or UART1 RX
-	D12	= PA22	// PWM available
-	D13	= PA23	// PWM available
-)
-```
-
-GPIO Pins
-
-
-```go
-const (
-	A0	= PA02	// ADC/AIN[0]
-	A1	= PA05	// ADC/AIN[2]
-	A2	= PB08	// ADC/AIN[3]
-	A3	= PB09	// ADC/AIN[4]
-	A4	= PA04	// ADC/AIN[5]
-	A5	= PA06	// ADC/AIN[6]
-	A6	= PB01	// ADC/AIN[12]/VMEAS
-	A7	= PB04	// ADC/AIN[6]/LIGHT
-	A8	= D2	// ADC/AIN[14]
-	A9	= D3	// ADC/AIN[15]
-)
-```
-
-Analog pins
-
-
-```go
-const (
-	LED		= D13
-	NEOPIXELS	= D8
-
-	SD_CS	= D7
-
-	LIGHTSENSOR	= A7
-
-	BUTTON_LATCH	= PB00
-	BUTTON_OUT	= PB30
-	BUTTON_CLK	= PB31
-
-	JOYY	= PB06
-	JOYX	= PB07
-
-	TFT_DC		= PB05
-	TFT_CS		= PB12
-	TFT_RST		= PA00
-	TFT_LITE	= PA01
-
-	SPEAKER_ENABLE	= PA27
-)
-```
-
-
-
-```go
-const (
-	BUTTON_SELECT_MASK	= 16
-	BUTTON_START_MASK	= 32
-	BUTTON_A_MASK		= 64
-	BUTTON_B_MASK		= 128
-)
-```
-
-
-
-```go
-const (
-	USBCDC_DM_PIN	= PA24
-	USBCDC_DP_PIN	= PA25
-)
-```
-
-UART0 aka USBCDC pins
-
-
-```go
-const (
-	UART_TX_PIN	= D1
-	UART_RX_PIN	= D0
-)
-```
-
-UART1 pins
-
-
-```go
-const (
-	UART2_TX_PIN	= A4
-	UART2_RX_PIN	= A5
-)
-```
-
-UART2 pins
-
-
-```go
-const (
-	SDA_PIN	= PA12	// SDA: SERCOM2/PAD[0]
-	SCL_PIN	= PA13	// SCL: SERCOM2/PAD[1]
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	= PA17	// SCK: SERCOM1/PAD[1]
-	SPI0_SDO_PIN	= PB23	// SDO: SERCOM1/PAD[3]
-	SPI0_SDI_PIN	= PB22	// SDI: SERCOM1/PAD[2]
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	SPI1_SCK_PIN	= PB13	// SCK: SERCOM4/PAD[1]
-	SPI1_SDO_PIN	= PB15	// SDO: SERCOM4/PAD[3]
-	SPI1_SDI_PIN	= NoPin
-)
-```
-
-TFT SPI pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const (
-	I2SModeSource	I2SMode	= iota
-	I2SModeReceiver
-	I2SModePDM
-)
-```
-
-
-
-```go
-const (
-	I2StandardPhilips	I2SStandard	= iota
-	I2SStandardMSB
-	I2SStandardLSB
-)
-```
-
-
-
-```go
-const (
-	I2SClockSourceInternal	I2SClockSource	= iota
-	I2SClockSourceExternal
-)
-```
-
-
-
-```go
-const (
-	I2SDataFormatDefault	I2SDataFormat	= 0
-	I2SDataFormat8bit			= 8
-	I2SDataFormat16bit			= 16
-	I2SDataFormat24bit			= 24
-	I2SDataFormat32bit			= 32
-)
-```
-
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinAnalog		PinMode	= 1
-	PinSERCOM		PinMode	= 2
-	PinSERCOMAlt		PinMode	= 3
-	PinTimer		PinMode	= 4
-	PinTimerAlt		PinMode	= 5
-	PinTCCPDEC		PinMode	= 6
-	PinCom			PinMode	= 7
-	PinSDHC			PinMode	= 8
-	PinI2S			PinMode	= 9
-	PinPCC			PinMode	= 10
-	PinGMAC			PinMode	= 11
-	PinACCLK		PinMode	= 12
-	PinCCL			PinMode	= 13
-	PinDigital		PinMode	= 14
-	PinInput		PinMode	= 15
-	PinInputPullup		PinMode	= 16
-	PinOutput		PinMode	= 17
-	PinPWME			PinMode	= PinTimer
-	PinPWMF			PinMode	= PinTimerAlt
-	PinPWMG			PinMode	= PinTCCPDEC
-	PinInputPulldown	PinMode	= 18
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
-	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
-	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	PA00	Pin	= 0
-	PA01	Pin	= 1
-	PA02	Pin	= 2
-	PA03	Pin	= 3
-	PA04	Pin	= 4
-	PA05	Pin	= 5
-	PA06	Pin	= 6
-	PA07	Pin	= 7
-	PA08	Pin	= 8
-	PA09	Pin	= 9
-	PA10	Pin	= 10
-	PA11	Pin	= 11
-	PA12	Pin	= 12
-	PA13	Pin	= 13
-	PA14	Pin	= 14
-	PA15	Pin	= 15
-	PA16	Pin	= 16
-	PA17	Pin	= 17
-	PA18	Pin	= 18
-	PA19	Pin	= 19
-	PA20	Pin	= 20
-	PA21	Pin	= 21
-	PA22	Pin	= 22
-	PA23	Pin	= 23
-	PA24	Pin	= 24
-	PA25	Pin	= 25
-	PA26	Pin	= 26
-	PA27	Pin	= 27
-	PA28	Pin	= 28
-	PA29	Pin	= 29
-	PA30	Pin	= 30
-	PA31	Pin	= 31
-	PB00	Pin	= 32
-	PB01	Pin	= 33
-	PB02	Pin	= 34
-	PB03	Pin	= 35
-	PB04	Pin	= 36
-	PB05	Pin	= 37
-	PB06	Pin	= 38
-	PB07	Pin	= 39
-	PB08	Pin	= 40
-	PB09	Pin	= 41
-	PB10	Pin	= 42
-	PB11	Pin	= 43
-	PB12	Pin	= 44
-	PB13	Pin	= 45
-	PB14	Pin	= 46
-	PB15	Pin	= 47
-	PB16	Pin	= 48
-	PB17	Pin	= 49
-	PB18	Pin	= 50
-	PB19	Pin	= 51
-	PB20	Pin	= 52
-	PB21	Pin	= 53
-	PB22	Pin	= 54
-	PB23	Pin	= 55
-	PB24	Pin	= 56
-	PB25	Pin	= 57
-	PB26	Pin	= 58
-	PB27	Pin	= 59
-	PB28	Pin	= 60
-	PB29	Pin	= 61
-	PB30	Pin	= 62
-	PB31	Pin	= 63
-	PC00	Pin	= 64
-	PC01	Pin	= 65
-	PC02	Pin	= 66
-	PC03	Pin	= 67
-	PC04	Pin	= 68
-	PC05	Pin	= 69
-	PC06	Pin	= 70
-	PC07	Pin	= 71
-	PC08	Pin	= 72
-	PC09	Pin	= 73
-	PC10	Pin	= 74
-	PC11	Pin	= 75
-	PC12	Pin	= 76
-	PC13	Pin	= 77
-	PC14	Pin	= 78
-	PC15	Pin	= 79
-	PC16	Pin	= 80
-	PC17	Pin	= 81
-	PC18	Pin	= 82
-	PC19	Pin	= 83
-	PC20	Pin	= 84
-	PC21	Pin	= 85
-	PC22	Pin	= 86
-	PC23	Pin	= 87
-	PC24	Pin	= 88
-	PC25	Pin	= 89
-	PC26	Pin	= 90
-	PC27	Pin	= 91
-	PC28	Pin	= 92
-	PC29	Pin	= 93
-	PC30	Pin	= 94
-	PC31	Pin	= 95
-	PD00	Pin	= 96
-	PD01	Pin	= 97
-	PD02	Pin	= 98
-	PD03	Pin	= 99
-	PD04	Pin	= 100
-	PD05	Pin	= 101
-	PD06	Pin	= 102
-	PD07	Pin	= 103
-	PD08	Pin	= 104
-	PD09	Pin	= 105
-	PD10	Pin	= 106
-	PD11	Pin	= 107
-	PD12	Pin	= 108
-	PD13	Pin	= 109
-	PD14	Pin	= 110
-	PD15	Pin	= 111
-	PD16	Pin	= 112
-	PD17	Pin	= 113
-	PD18	Pin	= 114
-	PD19	Pin	= 115
-	PD20	Pin	= 116
-	PD21	Pin	= 117
-	PD22	Pin	= 118
-	PD23	Pin	= 119
-	PD24	Pin	= 120
-	PD25	Pin	= 121
-	PD26	Pin	= 122
-	PD27	Pin	= 123
-	PD28	Pin	= 124
-	PD29	Pin	= 125
-	PD30	Pin	= 126
-	PD31	Pin	= 127
-)
-```
-
-Hardware pins
-
-
-```go
-const (
-	// SERCOM_FREQ_REF is always reference frequency on SAMD51 regardless of CPU speed.
-	SERCOM_FREQ_REF	= 48000000
-
-	// Default rise time in nanoseconds, based on 4.7K ohm pull up resistors
-	riseTimeNanoseconds	= 125
-
-	// wire bus states
-	wireUnknownState	= 0
-	wireIdleState		= 1
-	wireOwnerState		= 2
-	wireBusyState		= 3
-
-	// wire commands
-	wireCmdNoAction		= 0
-	wireCmdRepeatStart	= 1
-	wireCmdRead		= 2
-	wireCmdStop		= 3
-)
-```
-
-
-
-```go
-const (
-	QSPI_SCK	= PB10
-	QSPI_CS		= PB11
-	QSPI_DATA0	= PA08
-	QSPI_DATA1	= PA09
-	QSPI_DATA2	= PA10
-	QSPI_DATA3	= PA11
-)
-```
-
-The QSPI peripheral on ATSAMD51 is only available on the following pins
-
-
-```go
-const HSRAM_SIZE = 0x00030000
-```
-
-
-
-```go
-const (
-	Mode0	= 0
-	Mode1	= 1
-	Mode2	= 2
-	Mode3	= 3
-)
-```
-
-SPI phase and polarity configs CPOL and CPHA
-
-
-
-
-
-## Variables
-
-```go
-var (
-	I2C0 = I2C{
-		Bus:	sam.SERCOM2_I2CM,
-		SERCOM:	2,
-	}
-)
-```
-
-I2C on the PyGamer.
-
-
-```go
-var (
-	SPI0 = SPI{
-		Bus:	sam.SERCOM1_SPIM,
-		SERCOM:	1,
-	}
-)
-```
-
-SPI on the PyGamer.
-
-
-```go
-var (
-	SPI1 = SPI{
-		Bus:	sam.SERCOM4_SPIM,
-		SERCOM:	4,
-	}
-)
-```
-
-TFT SPI on the PyGamer.
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	// UART0 is actually a USB CDC interface.
-	UART0 = USBCDC{Buffer: NewRingBuffer()}
-)
-```
-
-
-
-```go
-var (
-	DAC0 = DAC{}
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the PWM interface.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-### func ResetProcessor
-
-```go
-func ResetProcessor()
-```
-
-ResetProcessor should perform a system reset in preparation
-to switch to the bootloader to flash new firmware.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure()
-```
-
-Configure configures a ADCPin to be able to be used to read data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin, in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DAC
-
-```go
-type DAC struct {
-}
-```
-
-DAC on the SAMD51.
-
-
-
-### func (DAC) Configure
-
-```go
-func (dac DAC) Configure(config DACConfig)
-```
-
-Configure the DAC.
-output pin must already be configured.
-
-
-### func (DAC) Set
-
-```go
-func (dac DAC) Set(value uint16) error
-```
-
-Set writes a single 16-bit value to the DAC.
-Since the ATSAMD51 only has a 12-bit DAC, the passed-in value will be scaled down.
-
-
-
-
-## type DACConfig
-
-```go
-type DACConfig struct {
-}
-```
-
-DACConfig placeholder for future expansion.
-
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus	*sam.SERCOM_I2CM_Type
-	SERCOM	uint8
-}
-```
-
-I2C on the SAMD51.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig) error
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) SetBaudRate
-
-```go
-func (i2c I2C) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the I2C.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteByte
-
-```go
-func (i2c I2C) WriteByte(data byte) error
-```
-
-WriteByte writes a single byte to the I2C bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type I2SClockSource
-
-```go
-type I2SClockSource uint8
-```
-
-
-
-
-
-
-## type I2SConfig
-
-```go
-type I2SConfig struct {
-	SCK		Pin
-	WS		Pin
-	SD		Pin
-	Mode		I2SMode
-	Standard	I2SStandard
-	ClockSource	I2SClockSource
-	DataFormat	I2SDataFormat
-	AudioFrequency	uint32
-	MainClockOutput	bool
-	Stereo		bool
-}
-```
-
-All fields are optional and may not be required or used on a particular platform.
-
-
-
-
-
-## type I2SDataFormat
-
-```go
-type I2SDataFormat uint8
-```
-
-
-
-
-
-
-## type I2SMode
-
-```go
-type I2SMode uint8
-```
-
-
-
-
-
-
-## type I2SStandard
-
-```go
-type I2SStandard uint8
-```
-
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure() error
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-### func (Pin) Toggle
-
-```go
-func (p Pin) Toggle()
-```
-
-Toggle switches an output pin from low to high or from high to low.
-Warning: only use this on an output pin!
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus	*sam.SERCOM_SPIM_Type
-	SERCOM	uint8
-}
-```
-
-SPI
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig) error
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer		*RingBuffer
-	Bus		*sam.SERCOM_USART_INT_Type
-	SERCOM		uint8
-	Interrupt	interrupt.Interrupt	// RXC interrupt
-}
-```
-
-UART on the SAMD51.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig) error
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer *RingBuffer
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the SAMD21.
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (USBCDC) Configure
-
-```go
-func (usbcdc USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/pyportal.md b/content/microcontrollers/machine/pyportal.md
deleted file mode 100644
index b66da68f..00000000
--- a/content/microcontrollers/machine/pyportal.md
+++ /dev/null
@@ -1,1727 +0,0 @@
-
----
-title: pyportal
----
-
-
-## Constants
-
-```go
-const RESET_MAGIC_VALUE = 0xf01669ef
-```
-
-used to reset into bootloader
-
-
-```go
-const (
-	D0	= PB13	// NINA_RX
-	D1	= PB12	// NINA_TX
-	D2	= PB22	// built-in neopixel
-	D3	= PA04	// PWM available
-	D4	= PA05	// PWM available
-	D5	= PB16	// NINA_ACK
-	D6	= PB15	// NINA_GPIO0
-	D7	= PB17	// NINA_RESETN
-	D8	= PB14	// NINA_CS
-	D9	= PB04	// TFT_RD
-	D10	= PB05	// TFT_DC
-	D11	= PB06	// TFT_CS
-	D12	= PB07	// TFT_TE
-	D13	= PB23	// built-in LED
-	D24	= PA00	// TFT_RESET
-	D25	= PB31	// TFT_BACKLIGHT
-	D26	= PB09	// TFT_WR
-	D27	= PB02	// SDA
-	D28	= PB03	// SCL
-	D29	= PA12	// SDO
-	D30	= PA13	// SCK
-	D31	= PA14	// SDI
-	D32	= PB30	// SD_CS
-	D33	= PA01	// SD_CARD_DETECT
-	D34	= PA16	// LCD_DATA0
-	D35	= PA17	// LCD_DATA1
-	D36	= PA18	// LCD_DATA2
-	D37	= PA19	// LCD_DATA3
-	D38	= PA20	// LCD_DATA4
-	D39	= PA21	// LCD_DATA5
-	D40	= PA22	// LCD_DATA6
-	D41	= PA23	// LCD_DATA7
-	D42	= PB10	// QSPI
-	D43	= PB11	// QSPI
-	D44	= PA08	// QSPI
-	D45	= PA09	// QSPI
-	D46	= PA10	// QSPI
-	D47	= PA11	// QSPI
-	D50	= PA02	// speaker amplifier shutdown
-	D51	= PA15	// NINA_RTS
-
-	NINA_CS		= D8
-	NINA_ACK	= D5
-	NINA_GPIO0	= D6
-	NINA_RESETN	= D7
-
-	NINA_TX		= D1
-	NINA_RX		= D0
-	NINA_RTS	= D51
-
-	LCD_DATA0	= D34
-
-	TFT_RD		= D9
-	TFT_DC		= D10
-	TFT_CS		= D11
-	TFT_TE		= D12
-	TFT_RESET	= D24
-	TFT_BACKLIGHT	= D25
-	TFT_WR		= D26
-
-	NEOPIXEL	= D2
-	SPK_SD		= D50
-)
-```
-
-GPIO Pins
-
-
-```go
-const (
-	A0	= PA02	// ADC0/AIN[0]
-	A1	= D3	// ADC0/AIN[4]
-	A2	= PA07	// ADC0/AIN[7]
-	A3	= D4	// ADC0/AIN[5]
-	A4	= PB00	// ADC0/AIN[12]
-	A5	= PB01	// ADC0/AIN[13]
-	A6	= PA06	// ADC0/AIN[6]
-	A7	= PB08	// ADC1/AIN[0]
-
-	AUDIO_OUT	= A0
-	LIGHT		= A2
-	TOUCH_YD	= A4
-	TOUCH_XL	= A5
-	TOUCH_YU	= A6
-	TOUCH_XR	= A7
-)
-```
-
-Analog pins
-
-
-```go
-const (
-	LED = D13
-)
-```
-
-
-
-```go
-const (
-	USBCDC_DM_PIN	= PA24
-	USBCDC_DP_PIN	= PA25
-)
-```
-
-UART0 aka USBCDC pins
-
-
-```go
-const (
-	UART_TX_PIN	= D1
-	UART_RX_PIN	= D0
-)
-```
-
-UART1 aka NINA_TX/NINA_RX
-
-
-```go
-const (
-	SDA_PIN	= PB02	// SDA: SERCOM2/PAD[0]
-	SCL_PIN	= PB03	// SCL: SERCOM2/PAD[1]
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	= PA13	// SCK: SERCOM1/PAD[1]
-	SPI0_SDO_PIN	= PA12	// SDO: SERCOM1/PAD[3]
-	SPI0_SDI_PIN	= PA14	// SDI: SERCOM1/PAD[2]
-
-	NINA_SDO	= SPI0_SDO_PIN
-	NINA_SDI	= SPI0_SDI_PIN
-	NINA_SCK	= SPI0_SCK_PIN
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const (
-	I2SModeSource	I2SMode	= iota
-	I2SModeReceiver
-	I2SModePDM
-)
-```
-
-
-
-```go
-const (
-	I2StandardPhilips	I2SStandard	= iota
-	I2SStandardMSB
-	I2SStandardLSB
-)
-```
-
-
-
-```go
-const (
-	I2SClockSourceInternal	I2SClockSource	= iota
-	I2SClockSourceExternal
-)
-```
-
-
-
-```go
-const (
-	I2SDataFormatDefault	I2SDataFormat	= 0
-	I2SDataFormat8bit			= 8
-	I2SDataFormat16bit			= 16
-	I2SDataFormat24bit			= 24
-	I2SDataFormat32bit			= 32
-)
-```
-
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinAnalog		PinMode	= 1
-	PinSERCOM		PinMode	= 2
-	PinSERCOMAlt		PinMode	= 3
-	PinTimer		PinMode	= 4
-	PinTimerAlt		PinMode	= 5
-	PinTCCPDEC		PinMode	= 6
-	PinCom			PinMode	= 7
-	PinSDHC			PinMode	= 8
-	PinI2S			PinMode	= 9
-	PinPCC			PinMode	= 10
-	PinGMAC			PinMode	= 11
-	PinACCLK		PinMode	= 12
-	PinCCL			PinMode	= 13
-	PinDigital		PinMode	= 14
-	PinInput		PinMode	= 15
-	PinInputPullup		PinMode	= 16
-	PinOutput		PinMode	= 17
-	PinPWME			PinMode	= PinTimer
-	PinPWMF			PinMode	= PinTimerAlt
-	PinPWMG			PinMode	= PinTCCPDEC
-	PinInputPulldown	PinMode	= 18
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
-	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
-	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	PA00	Pin	= 0
-	PA01	Pin	= 1
-	PA02	Pin	= 2
-	PA03	Pin	= 3
-	PA04	Pin	= 4
-	PA05	Pin	= 5
-	PA06	Pin	= 6
-	PA07	Pin	= 7
-	PA08	Pin	= 8
-	PA09	Pin	= 9
-	PA10	Pin	= 10
-	PA11	Pin	= 11
-	PA12	Pin	= 12
-	PA13	Pin	= 13
-	PA14	Pin	= 14
-	PA15	Pin	= 15
-	PA16	Pin	= 16
-	PA17	Pin	= 17
-	PA18	Pin	= 18
-	PA19	Pin	= 19
-	PA20	Pin	= 20
-	PA21	Pin	= 21
-	PA22	Pin	= 22
-	PA23	Pin	= 23
-	PA24	Pin	= 24
-	PA25	Pin	= 25
-	PA26	Pin	= 26
-	PA27	Pin	= 27
-	PA28	Pin	= 28
-	PA29	Pin	= 29
-	PA30	Pin	= 30
-	PA31	Pin	= 31
-	PB00	Pin	= 32
-	PB01	Pin	= 33
-	PB02	Pin	= 34
-	PB03	Pin	= 35
-	PB04	Pin	= 36
-	PB05	Pin	= 37
-	PB06	Pin	= 38
-	PB07	Pin	= 39
-	PB08	Pin	= 40
-	PB09	Pin	= 41
-	PB10	Pin	= 42
-	PB11	Pin	= 43
-	PB12	Pin	= 44
-	PB13	Pin	= 45
-	PB14	Pin	= 46
-	PB15	Pin	= 47
-	PB16	Pin	= 48
-	PB17	Pin	= 49
-	PB18	Pin	= 50
-	PB19	Pin	= 51
-	PB20	Pin	= 52
-	PB21	Pin	= 53
-	PB22	Pin	= 54
-	PB23	Pin	= 55
-	PB24	Pin	= 56
-	PB25	Pin	= 57
-	PB26	Pin	= 58
-	PB27	Pin	= 59
-	PB28	Pin	= 60
-	PB29	Pin	= 61
-	PB30	Pin	= 62
-	PB31	Pin	= 63
-	PC00	Pin	= 64
-	PC01	Pin	= 65
-	PC02	Pin	= 66
-	PC03	Pin	= 67
-	PC04	Pin	= 68
-	PC05	Pin	= 69
-	PC06	Pin	= 70
-	PC07	Pin	= 71
-	PC08	Pin	= 72
-	PC09	Pin	= 73
-	PC10	Pin	= 74
-	PC11	Pin	= 75
-	PC12	Pin	= 76
-	PC13	Pin	= 77
-	PC14	Pin	= 78
-	PC15	Pin	= 79
-	PC16	Pin	= 80
-	PC17	Pin	= 81
-	PC18	Pin	= 82
-	PC19	Pin	= 83
-	PC20	Pin	= 84
-	PC21	Pin	= 85
-	PC22	Pin	= 86
-	PC23	Pin	= 87
-	PC24	Pin	= 88
-	PC25	Pin	= 89
-	PC26	Pin	= 90
-	PC27	Pin	= 91
-	PC28	Pin	= 92
-	PC29	Pin	= 93
-	PC30	Pin	= 94
-	PC31	Pin	= 95
-	PD00	Pin	= 96
-	PD01	Pin	= 97
-	PD02	Pin	= 98
-	PD03	Pin	= 99
-	PD04	Pin	= 100
-	PD05	Pin	= 101
-	PD06	Pin	= 102
-	PD07	Pin	= 103
-	PD08	Pin	= 104
-	PD09	Pin	= 105
-	PD10	Pin	= 106
-	PD11	Pin	= 107
-	PD12	Pin	= 108
-	PD13	Pin	= 109
-	PD14	Pin	= 110
-	PD15	Pin	= 111
-	PD16	Pin	= 112
-	PD17	Pin	= 113
-	PD18	Pin	= 114
-	PD19	Pin	= 115
-	PD20	Pin	= 116
-	PD21	Pin	= 117
-	PD22	Pin	= 118
-	PD23	Pin	= 119
-	PD24	Pin	= 120
-	PD25	Pin	= 121
-	PD26	Pin	= 122
-	PD27	Pin	= 123
-	PD28	Pin	= 124
-	PD29	Pin	= 125
-	PD30	Pin	= 126
-	PD31	Pin	= 127
-)
-```
-
-Hardware pins
-
-
-```go
-const (
-	// SERCOM_FREQ_REF is always reference frequency on SAMD51 regardless of CPU speed.
-	SERCOM_FREQ_REF	= 48000000
-
-	// Default rise time in nanoseconds, based on 4.7K ohm pull up resistors
-	riseTimeNanoseconds	= 125
-
-	// wire bus states
-	wireUnknownState	= 0
-	wireIdleState		= 1
-	wireOwnerState		= 2
-	wireBusyState		= 3
-
-	// wire commands
-	wireCmdNoAction		= 0
-	wireCmdRepeatStart	= 1
-	wireCmdRead		= 2
-	wireCmdStop		= 3
-)
-```
-
-
-
-```go
-const (
-	QSPI_SCK	= PB10
-	QSPI_CS		= PB11
-	QSPI_DATA0	= PA08
-	QSPI_DATA1	= PA09
-	QSPI_DATA2	= PA10
-	QSPI_DATA3	= PA11
-)
-```
-
-The QSPI peripheral on ATSAMD51 is only available on the following pins
-
-
-```go
-const HSRAM_SIZE = 0x00040000
-```
-
-
-
-```go
-const (
-	Mode0	= 0
-	Mode1	= 1
-	Mode2	= 2
-	Mode3	= 3
-)
-```
-
-SPI phase and polarity configs CPOL and CPHA
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART1 = UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	sam.SERCOM4_USART_INT,
-		SERCOM:	4,
-	}
-)
-```
-
-
-
-```go
-var (
-	I2C0 = I2C{
-		Bus:	sam.SERCOM5_I2CM,
-		SERCOM:	5,
-	}
-)
-```
-
-I2C on the PyPortal.
-
-
-```go
-var (
-	SPI0	= SPI{
-		Bus:	sam.SERCOM2_SPIM,
-		SERCOM:	2,
-	}
-	NINA_SPI	= SPI0
-)
-```
-
-SPI on the PyPortal.
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	// UART0 is actually a USB CDC interface.
-	UART0 = USBCDC{Buffer: NewRingBuffer()}
-)
-```
-
-
-
-```go
-var (
-	DAC0 = DAC{}
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the PWM interface.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-### func ResetProcessor
-
-```go
-func ResetProcessor()
-```
-
-ResetProcessor should perform a system reset in preparation
-to switch to the bootloader to flash new firmware.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure()
-```
-
-Configure configures a ADCPin to be able to be used to read data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin, in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DAC
-
-```go
-type DAC struct {
-}
-```
-
-DAC on the SAMD51.
-
-
-
-### func (DAC) Configure
-
-```go
-func (dac DAC) Configure(config DACConfig)
-```
-
-Configure the DAC.
-output pin must already be configured.
-
-
-### func (DAC) Set
-
-```go
-func (dac DAC) Set(value uint16) error
-```
-
-Set writes a single 16-bit value to the DAC.
-Since the ATSAMD51 only has a 12-bit DAC, the passed-in value will be scaled down.
-
-
-
-
-## type DACConfig
-
-```go
-type DACConfig struct {
-}
-```
-
-DACConfig placeholder for future expansion.
-
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus	*sam.SERCOM_I2CM_Type
-	SERCOM	uint8
-}
-```
-
-I2C on the SAMD51.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig) error
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) SetBaudRate
-
-```go
-func (i2c I2C) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the I2C.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteByte
-
-```go
-func (i2c I2C) WriteByte(data byte) error
-```
-
-WriteByte writes a single byte to the I2C bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type I2SClockSource
-
-```go
-type I2SClockSource uint8
-```
-
-
-
-
-
-
-## type I2SConfig
-
-```go
-type I2SConfig struct {
-	SCK		Pin
-	WS		Pin
-	SD		Pin
-	Mode		I2SMode
-	Standard	I2SStandard
-	ClockSource	I2SClockSource
-	DataFormat	I2SDataFormat
-	AudioFrequency	uint32
-	MainClockOutput	bool
-	Stereo		bool
-}
-```
-
-All fields are optional and may not be required or used on a particular platform.
-
-
-
-
-
-## type I2SDataFormat
-
-```go
-type I2SDataFormat uint8
-```
-
-
-
-
-
-
-## type I2SMode
-
-```go
-type I2SMode uint8
-```
-
-
-
-
-
-
-## type I2SStandard
-
-```go
-type I2SStandard uint8
-```
-
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure() error
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-### func (Pin) Toggle
-
-```go
-func (p Pin) Toggle()
-```
-
-Toggle switches an output pin from low to high or from high to low.
-Warning: only use this on an output pin!
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus	*sam.SERCOM_SPIM_Type
-	SERCOM	uint8
-}
-```
-
-SPI
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig) error
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer		*RingBuffer
-	Bus		*sam.SERCOM_USART_INT_Type
-	SERCOM		uint8
-	Interrupt	interrupt.Interrupt	// RXC interrupt
-}
-```
-
-UART on the SAMD51.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig) error
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer *RingBuffer
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the SAMD21.
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (USBCDC) Configure
-
-```go
-func (usbcdc USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/qtpy.md b/content/microcontrollers/machine/qtpy.md
deleted file mode 100644
index 3f0403a2..00000000
--- a/content/microcontrollers/machine/qtpy.md
+++ /dev/null
@@ -1,1609 +0,0 @@
-
----
-title: qtpy
----
-
-
-## Constants
-
-```go
-const (
-	PA00	Pin	= 0
-	PA01	Pin	= 1
-	PA02	Pin	= 2
-	PA03	Pin	= 3
-	PA04	Pin	= 4
-	PA05	Pin	= 5
-	PA06	Pin	= 6
-	PA07	Pin	= 7
-	PA08	Pin	= 8
-	PA09	Pin	= 9
-	PA10	Pin	= 10
-	PA11	Pin	= 11
-	PA12	Pin	= 12
-	PA13	Pin	= 13
-	PA14	Pin	= 14
-	PA15	Pin	= 15
-	PA16	Pin	= 16
-	PA17	Pin	= 17
-	PA18	Pin	= 18
-	PA19	Pin	= 19
-	PA20	Pin	= 20
-	PA21	Pin	= 21
-	PA22	Pin	= 22
-	PA23	Pin	= 23
-	PA24	Pin	= 24
-	PA25	Pin	= 25
-	PA26	Pin	= 26
-	PA27	Pin	= 27
-	PA28	Pin	= 28
-	PA29	Pin	= 29
-	PA30	Pin	= 30
-	PA31	Pin	= 31
-	PB00	Pin	= 32
-	PB01	Pin	= 33
-	PB02	Pin	= 34
-	PB03	Pin	= 35
-	PB04	Pin	= 36
-	PB05	Pin	= 37
-	PB06	Pin	= 38
-	PB07	Pin	= 39
-	PB08	Pin	= 40
-	PB09	Pin	= 41
-	PB10	Pin	= 42
-	PB11	Pin	= 43
-	PB12	Pin	= 44
-	PB13	Pin	= 45
-	PB14	Pin	= 46
-	PB15	Pin	= 47
-	PB16	Pin	= 48
-	PB17	Pin	= 49
-	PB18	Pin	= 50
-	PB19	Pin	= 51
-	PB20	Pin	= 52
-	PB21	Pin	= 53
-	PB22	Pin	= 54
-	PB23	Pin	= 55
-	PB24	Pin	= 56
-	PB25	Pin	= 57
-	PB26	Pin	= 58
-	PB27	Pin	= 59
-	PB28	Pin	= 60
-	PB29	Pin	= 61
-	PB30	Pin	= 62
-	PB31	Pin	= 63
-)
-```
-
-Hardware pins
-
-
-```go
-const RESET_MAGIC_VALUE = 0xf01669ef
-```
-
-used to reset into bootloader
-
-
-```go
-const (
-	D0	= PA02	// PWM available
-	D1	= PA03
-	D2	= PA04	// PWM available
-	D3	= PA05	// PWM available
-	D4	= PA16	// PWM available
-	D5	= PA17	// PWM available
-	D6	= PA06
-	D7	= PA07
-	D8	= PA11
-	D9	= PA09
-	D10	= PA10
-	D11	= PA18
-	D12	= PA15
-	D13	= PA27
-	D14	= PA23
-	D15	= PA19
-	D16	= PA22
-	D17	= PA08
-)
-```
-
-GPIO Pins
-
-
-```go
-const (
-	A0	= D1
-	A1	= D1
-	A2	= D2
-	A3	= D3
-	A4	= D4
-)
-```
-
-Analog pins
-
-
-```go
-const (
-	LED = D13
-)
-```
-
-
-
-```go
-const (
-	USBCDC_DM_PIN	= PA24
-	USBCDC_DP_PIN	= PA25
-)
-```
-
-UART0 aka USBCDC pins
-
-
-```go
-const (
-	UART_TX_PIN	= D6
-	UART_RX_PIN	= D7
-)
-```
-
-UART1 pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	= D8
-	SPI0_SDO_PIN	= D10
-	SPI0_SDI_PIN	= D9
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	SDA_PIN	= D4	// SDA
-	SCL_PIN	= D5	// SCL
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	I2S_SCK_PIN	= PA10
-	I2S_SD_PIN	= PA08
-	I2S_WS_PIN	= NoPin	// TODO: figure out what this is on QT Py M0.
-)
-```
-
-I2S pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const (
-	I2SModeSource	I2SMode	= iota
-	I2SModeReceiver
-	I2SModePDM
-)
-```
-
-
-
-```go
-const (
-	I2StandardPhilips	I2SStandard	= iota
-	I2SStandardMSB
-	I2SStandardLSB
-)
-```
-
-
-
-```go
-const (
-	I2SClockSourceInternal	I2SClockSource	= iota
-	I2SClockSourceExternal
-)
-```
-
-
-
-```go
-const (
-	I2SDataFormatDefault	I2SDataFormat	= 0
-	I2SDataFormat8bit			= 8
-	I2SDataFormat16bit			= 16
-	I2SDataFormat24bit			= 24
-	I2SDataFormat32bit			= 32
-)
-```
-
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinAnalog	PinMode	= 1
-	PinSERCOM	PinMode	= 2
-	PinSERCOMAlt	PinMode	= 3
-	PinTimer	PinMode	= 4
-	PinTimerAlt	PinMode	= 5
-	PinCom		PinMode	= 6
-	//PinAC_CLK        PinMode = 7
-	PinDigital		PinMode	= 8
-	PinInput		PinMode	= 9
-	PinInputPullup		PinMode	= 10
-	PinOutput		PinMode	= 11
-	PinPWM			PinMode	= PinTimer
-	PinPWMAlt		PinMode	= PinTimerAlt
-	PinInputPulldown	PinMode	= 12
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
-	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
-	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	Mode0	= 0
-	Mode1	= 1
-	Mode2	= 2
-	Mode3	= 3
-)
-```
-
-SPI phase and polarity configs CPOL and CPHA
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART1 = UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	sam.SERCOM0_USART,
-		SERCOM:	0,
-	}
-)
-```
-
-UART1 on the QT Py M0.
-
-
-```go
-var (
-	SPI0 = SPI{
-		Bus:	sam.SERCOM0_SPI,
-		SERCOM:	0,
-	}
-)
-```
-
-SPI on the QT Py M0.
-
-
-```go
-var (
-	I2C0 = I2C{
-		Bus:	sam.SERCOM2_I2CM,
-		SERCOM:	2,
-	}
-)
-```
-
-I2C on the QT Py M0.
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	// UART0 is actually a USB CDC interface.
-	UART0 = USBCDC{Buffer: NewRingBuffer()}
-)
-```
-
-
-
-```go
-var (
-	DAC0 = DAC{}
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-Return the current CPU frequency in hertz.
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the PWM interface.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-### func ResetProcessor
-
-```go
-func ResetProcessor()
-```
-
-ResetProcessor should perform a system reset in preperation
-to switch to the bootloader to flash new firmware.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure()
-```
-
-Configure configures a ADCPin to be able to be used to read data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin, in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DAC
-
-```go
-type DAC struct {
-}
-```
-
-DAC on the SAMD21.
-
-
-
-### func (DAC) Configure
-
-```go
-func (dac DAC) Configure(config DACConfig)
-```
-
-Configure the DAC.
-output pin must already be configured.
-
-
-### func (DAC) Set
-
-```go
-func (dac DAC) Set(value uint16) error
-```
-
-Set writes a single 16-bit value to the DAC.
-Since the ATSAMD21 only has a 10-bit DAC, the passed-in value will be scaled down.
-
-
-
-
-## type DACConfig
-
-```go
-type DACConfig struct {
-}
-```
-
-DACConfig placeholder for future expansion.
-
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus	*sam.SERCOM_I2CM_Type
-	SERCOM	uint8
-}
-```
-
-I2C on the SAMD21.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig) error
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) SetBaudRate
-
-```go
-func (i2c I2C) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the I2C.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteByte
-
-```go
-func (i2c I2C) WriteByte(data byte) error
-```
-
-WriteByte writes a single byte to the I2C bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type I2S
-
-```go
-type I2S struct {
-	Bus *sam.I2S_Type
-}
-```
-
-I2S
-
-
-
-### func (I2S) Close
-
-```go
-func (i2s I2S) Close() error
-```
-
-Close the I2S bus.
-
-
-### func (I2S) Configure
-
-```go
-func (i2s I2S) Configure(config I2SConfig)
-```
-
-Configure is used to configure the I2S interface. You must call this
-before you can use the I2S bus.
-
-
-### func (I2S) Read
-
-```go
-func (i2s I2S) Read(p []uint32) (n int, err error)
-```
-
-Read data from the I2S bus into the provided slice.
-The I2S bus must already have been configured correctly.
-
-
-### func (I2S) Write
-
-```go
-func (i2s I2S) Write(p []uint32) (n int, err error)
-```
-
-Write data to the I2S bus from the provided slice.
-The I2S bus must already have been configured correctly.
-
-
-
-
-## type I2SClockSource
-
-```go
-type I2SClockSource uint8
-```
-
-
-
-
-
-
-## type I2SConfig
-
-```go
-type I2SConfig struct {
-	SCK		Pin
-	WS		Pin
-	SD		Pin
-	Mode		I2SMode
-	Standard	I2SStandard
-	ClockSource	I2SClockSource
-	DataFormat	I2SDataFormat
-	AudioFrequency	uint32
-	MainClockOutput	bool
-	Stereo		bool
-}
-```
-
-All fields are optional and may not be required or used on a particular platform.
-
-
-
-
-
-## type I2SDataFormat
-
-```go
-type I2SDataFormat uint8
-```
-
-
-
-
-
-
-## type I2SMode
-
-```go
-type I2SMode uint8
-```
-
-
-
-
-
-
-## type I2SStandard
-
-```go
-type I2SStandard uint8
-```
-
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure() error
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus	*sam.SERCOM_SPI_Type
-	SERCOM	uint8
-}
-```
-
-SPI
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig) error
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer		*RingBuffer
-	Bus		*sam.SERCOM_USART_Type
-	SERCOM		uint8
-	Interrupt	interrupt.Interrupt
-}
-```
-
-UART on the SAMD21.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig) error
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer *RingBuffer
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the SAMD21.
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (USBCDC) Configure
-
-```go
-func (usbcdc USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/reelboard-s140v7.md b/content/microcontrollers/machine/reelboard-s140v7.md
deleted file mode 100644
index a16c363b..00000000
--- a/content/microcontrollers/machine/reelboard-s140v7.md
+++ /dev/null
@@ -1,1323 +0,0 @@
-
----
-title: reelboard-s140v7
----
-
-
-## Constants
-
-```go
-const HasLowFrequencyCrystal = true
-```
-
-
-
-```go
-const (
-	LED			Pin	= LED1
-	LED1			Pin	= LED_YELLOW
-	LED2			Pin	= LED_RED
-	LED3			Pin	= LED_GREEN
-	LED4			Pin	= LED_BLUE
-	LED_RED			Pin	= 11
-	LED_GREEN		Pin	= 12
-	LED_BLUE		Pin	= 41
-	LED_YELLOW		Pin	= 13
-	EPD_BUSY_PIN		Pin	= 14
-	EPD_RESET_PIN		Pin	= 15
-	EPD_DC_PIN		Pin	= 16
-	EPD_CS_PIN		Pin	= 17
-	EPD_SCK_PIN		Pin	= 19
-	EPD_SDO_PIN		Pin	= 20
-	POWER_SUPPLY_PIN	Pin	= 32
-)
-```
-
-Pins on the reel board
-
-
-```go
-const (
-	BUTTON Pin = 7
-)
-```
-
-User "a" button on the reel board
-
-
-```go
-const (
-	UART_TX_PIN	Pin	= 6
-	UART_RX_PIN	Pin	= 8
-)
-```
-
-UART pins
-
-
-```go
-const (
-	SDA_PIN	Pin	= 26
-	SCL_PIN	Pin	= 27
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	Pin	= 47
-	SPI0_SDO_PIN	Pin	= 45
-	SPI0_SDI_PIN	Pin	= 46
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Disconnect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
-	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
-	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	P0_00	Pin	= 0
-	P0_01	Pin	= 1
-	P0_02	Pin	= 2
-	P0_03	Pin	= 3
-	P0_04	Pin	= 4
-	P0_05	Pin	= 5
-	P0_06	Pin	= 6
-	P0_07	Pin	= 7
-	P0_08	Pin	= 8
-	P0_09	Pin	= 9
-	P0_10	Pin	= 10
-	P0_11	Pin	= 11
-	P0_12	Pin	= 12
-	P0_13	Pin	= 13
-	P0_14	Pin	= 14
-	P0_15	Pin	= 15
-	P0_16	Pin	= 16
-	P0_17	Pin	= 17
-	P0_18	Pin	= 18
-	P0_19	Pin	= 19
-	P0_20	Pin	= 20
-	P0_21	Pin	= 21
-	P0_22	Pin	= 22
-	P0_23	Pin	= 23
-	P0_24	Pin	= 24
-	P0_25	Pin	= 25
-	P0_26	Pin	= 26
-	P0_27	Pin	= 27
-	P0_28	Pin	= 28
-	P0_29	Pin	= 29
-	P0_30	Pin	= 30
-	P0_31	Pin	= 31
-	P1_00	Pin	= 32
-	P1_01	Pin	= 33
-	P1_02	Pin	= 34
-	P1_03	Pin	= 35
-	P1_04	Pin	= 36
-	P1_05	Pin	= 37
-	P1_06	Pin	= 38
-	P1_07	Pin	= 39
-	P1_08	Pin	= 40
-	P1_09	Pin	= 41
-	P1_10	Pin	= 42
-	P1_11	Pin	= 43
-	P1_12	Pin	= 44
-	P1_13	Pin	= 45
-	P1_14	Pin	= 46
-	P1_15	Pin	= 47
-)
-```
-
-Hardware pins
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART0 = NRF_UART0
-)
-```
-
-UART0 is the NRF UART
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-```go
-var (
-	// NRF_UART0 is the hardware UART on the NRF SoC.
-	NRF_UART0 = UART{Buffer: NewRingBuffer()}
-)
-```
-
-UART
-
-
-```go
-var (
-	I2C0	= I2C{Bus: nrf.TWI0}
-	I2C1	= I2C{Bus: nrf.TWI1}
-)
-```
-
-There are 2 I2C interfaces on the NRF.
-
-
-```go
-var (
-	SPI0	= SPI{Bus: nrf.SPI0}
-	SPI1	= SPI{Bus: nrf.SPI1}
-)
-```
-
-There are 2 SPI interfaces on the NRF5x.
-
-
-```go
-var (
-	USB	= USBCDC{Buffer: NewRingBuffer()}
-
-	usbEndpointDescriptors	[8]usbDeviceDescriptor
-
-	udd_ep_in_cache_buffer	[7][128]uint8
-	udd_ep_out_cache_buffer	[7][128]uint8
-
-	sendOnEP0DATADONE	struct {
-		ptr	*byte
-		count	int
-	}
-	isEndpointHalt		= false
-	isRemoteWakeUpEnabled	= false
-	endPoints		= []uint32{usb_ENDPOINT_TYPE_CONTROL,
-		(usb_ENDPOINT_TYPE_INTERRUPT | usbEndpointIn),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointOut),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointIn)}
-
-	usbConfiguration		uint8
-	usbSetInterface			uint8
-	usbLineInfo			= cdcLineInfo{115200, 0x00, 0x00, 0x08, 0x00}
-	epinen				uint32
-	epouten				uint32
-	easyDMABusy			volatile.Register8
-	epout0data_setlinecoding	bool
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the registers needed for ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the registers needed for PWM.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-### func PowerSupplyActive
-
-```go
-func PowerSupplyActive(active bool)
-```
-
-PowerSupplyActive enables the supply voltages for nRF52840 and peripherals (true) or only for nRF52840 (false)
-This controls the TPS610981 boost converter. You must turn the power supply active in order to use the EPD and
-other onboard peripherals.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure() error
-```
-
-Configure configures an ADC pin to be able to read analog data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus *nrf.TWI_Type
-}
-```
-
-I2C on the NRF.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) (err error)
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure()
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *nrf.SPI_Type
-}
-```
-
-SPI on the NRF.
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the NRF.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer		*RingBuffer
-	interrupt	interrupt.Interrupt
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the nRF52840
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (*USBCDC) Configure
-
-```go
-func (usbcdc *USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/reelboard.md b/content/microcontrollers/machine/reelboard.md
deleted file mode 100644
index 26d3f17f..00000000
--- a/content/microcontrollers/machine/reelboard.md
+++ /dev/null
@@ -1,1323 +0,0 @@
-
----
-title: reelboard
----
-
-
-## Constants
-
-```go
-const HasLowFrequencyCrystal = true
-```
-
-
-
-```go
-const (
-	LED			Pin	= LED1
-	LED1			Pin	= LED_YELLOW
-	LED2			Pin	= LED_RED
-	LED3			Pin	= LED_GREEN
-	LED4			Pin	= LED_BLUE
-	LED_RED			Pin	= 11
-	LED_GREEN		Pin	= 12
-	LED_BLUE		Pin	= 41
-	LED_YELLOW		Pin	= 13
-	EPD_BUSY_PIN		Pin	= 14
-	EPD_RESET_PIN		Pin	= 15
-	EPD_DC_PIN		Pin	= 16
-	EPD_CS_PIN		Pin	= 17
-	EPD_SCK_PIN		Pin	= 19
-	EPD_SDO_PIN		Pin	= 20
-	POWER_SUPPLY_PIN	Pin	= 32
-)
-```
-
-Pins on the reel board
-
-
-```go
-const (
-	BUTTON Pin = 7
-)
-```
-
-User "a" button on the reel board
-
-
-```go
-const (
-	UART_TX_PIN	Pin	= 6
-	UART_RX_PIN	Pin	= 8
-)
-```
-
-UART pins
-
-
-```go
-const (
-	SDA_PIN	Pin	= 26
-	SCL_PIN	Pin	= 27
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	Pin	= 47
-	SPI0_SDO_PIN	Pin	= 45
-	SPI0_SDI_PIN	Pin	= 46
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Disconnect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
-	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
-	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	P0_00	Pin	= 0
-	P0_01	Pin	= 1
-	P0_02	Pin	= 2
-	P0_03	Pin	= 3
-	P0_04	Pin	= 4
-	P0_05	Pin	= 5
-	P0_06	Pin	= 6
-	P0_07	Pin	= 7
-	P0_08	Pin	= 8
-	P0_09	Pin	= 9
-	P0_10	Pin	= 10
-	P0_11	Pin	= 11
-	P0_12	Pin	= 12
-	P0_13	Pin	= 13
-	P0_14	Pin	= 14
-	P0_15	Pin	= 15
-	P0_16	Pin	= 16
-	P0_17	Pin	= 17
-	P0_18	Pin	= 18
-	P0_19	Pin	= 19
-	P0_20	Pin	= 20
-	P0_21	Pin	= 21
-	P0_22	Pin	= 22
-	P0_23	Pin	= 23
-	P0_24	Pin	= 24
-	P0_25	Pin	= 25
-	P0_26	Pin	= 26
-	P0_27	Pin	= 27
-	P0_28	Pin	= 28
-	P0_29	Pin	= 29
-	P0_30	Pin	= 30
-	P0_31	Pin	= 31
-	P1_00	Pin	= 32
-	P1_01	Pin	= 33
-	P1_02	Pin	= 34
-	P1_03	Pin	= 35
-	P1_04	Pin	= 36
-	P1_05	Pin	= 37
-	P1_06	Pin	= 38
-	P1_07	Pin	= 39
-	P1_08	Pin	= 40
-	P1_09	Pin	= 41
-	P1_10	Pin	= 42
-	P1_11	Pin	= 43
-	P1_12	Pin	= 44
-	P1_13	Pin	= 45
-	P1_14	Pin	= 46
-	P1_15	Pin	= 47
-)
-```
-
-Hardware pins
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART0 = NRF_UART0
-)
-```
-
-UART0 is the NRF UART
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-```go
-var (
-	// NRF_UART0 is the hardware UART on the NRF SoC.
-	NRF_UART0 = UART{Buffer: NewRingBuffer()}
-)
-```
-
-UART
-
-
-```go
-var (
-	I2C0	= I2C{Bus: nrf.TWI0}
-	I2C1	= I2C{Bus: nrf.TWI1}
-)
-```
-
-There are 2 I2C interfaces on the NRF.
-
-
-```go
-var (
-	SPI0	= SPI{Bus: nrf.SPI0}
-	SPI1	= SPI{Bus: nrf.SPI1}
-)
-```
-
-There are 2 SPI interfaces on the NRF5x.
-
-
-```go
-var (
-	USB	= USBCDC{Buffer: NewRingBuffer()}
-
-	usbEndpointDescriptors	[8]usbDeviceDescriptor
-
-	udd_ep_in_cache_buffer	[7][128]uint8
-	udd_ep_out_cache_buffer	[7][128]uint8
-
-	sendOnEP0DATADONE	struct {
-		ptr	*byte
-		count	int
-	}
-	isEndpointHalt		= false
-	isRemoteWakeUpEnabled	= false
-	endPoints		= []uint32{usb_ENDPOINT_TYPE_CONTROL,
-		(usb_ENDPOINT_TYPE_INTERRUPT | usbEndpointIn),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointOut),
-		(usb_ENDPOINT_TYPE_BULK | usbEndpointIn)}
-
-	usbConfiguration		uint8
-	usbSetInterface			uint8
-	usbLineInfo			= cdcLineInfo{115200, 0x00, 0x00, 0x08, 0x00}
-	epinen				uint32
-	epouten				uint32
-	easyDMABusy			volatile.Register8
-	epout0data_setlinecoding	bool
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the registers needed for ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the registers needed for PWM.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-### func PowerSupplyActive
-
-```go
-func PowerSupplyActive(active bool)
-```
-
-PowerSupplyActive enables the supply voltages for nRF52840 and peripherals (true) or only for nRF52840 (false)
-This controls the TPS610981 boost converter. You must turn the power supply active in order to use the EPD and
-other onboard peripherals.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure() error
-```
-
-Configure configures an ADC pin to be able to read analog data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus *nrf.TWI_Type
-}
-```
-
-I2C on the NRF.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) (err error)
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure()
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *nrf.SPI_Type
-}
-```
-
-SPI on the NRF.
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the NRF.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer		*RingBuffer
-	interrupt	interrupt.Interrupt
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the nRF52840
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (*USBCDC) Configure
-
-```go
-func (usbcdc *USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/riscv-qemu.md b/content/microcontrollers/machine/riscv-qemu.md
deleted file mode 100644
index a0ed0e77..00000000
--- a/content/microcontrollers/machine/riscv-qemu.md
+++ /dev/null
@@ -1,177 +0,0 @@
-
----
-title: riscv-qemu
----
-
-
-## Constants
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-
-
-
-## Variables
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
diff --git a/content/microcontrollers/machine/stm32f4disco-1.md b/content/microcontrollers/machine/stm32f4disco-1.md
deleted file mode 100644
index 7923b7bf..00000000
--- a/content/microcontrollers/machine/stm32f4disco-1.md
+++ /dev/null
@@ -1,649 +0,0 @@
-
----
-title: stm32f4disco-1
----
-
-
-## Constants
-
-```go
-const (
-	LED		= LED_BUILTIN
-	LED1		= LED_GREEN
-	LED2		= LED_ORANGE
-	LED3		= LED_RED
-	LED4		= LED_BLUE
-	LED_BUILTIN	= LED_GREEN
-	LED_GREEN	= PD12
-	LED_ORANGE	= PD13
-	LED_RED		= PD14
-	LED_BLUE	= PD15
-)
-```
-
-
-
-```go
-const (
-	UART_TX_PIN	= PA2
-	UART_RX_PIN	= PA3
-)
-```
-
-UART pins
-
-
-```go
-const (
-	SPI1_SCK_PIN	= PA5
-	SPI1_SDI_PIN	= PA6
-	SPI1_SDO_PIN	= PA7
-	SPI0_SCK_PIN	= SPI1_SCK_PIN
-	SPI0_SDI_PIN	= SPI1_SDI_PIN
-	SPI0_SDO_PIN	= SPI1_SDO_PIN
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	MEMS_ACCEL_CS	= PE3
-	MEMS_ACCEL_INT1	= PE0
-	MEMS_ACCEL_INT2	= PE1
-)
-```
-
-MEMs accelerometer
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	// Mode Flag
-	PinOutput		PinMode	= 0
-	PinInput		PinMode	= PinInputFloating
-	PinInputFloating	PinMode	= 1
-	PinInputPulldown	PinMode	= 2
-	PinInputPullup		PinMode	= 3
-
-	// for UART
-	PinModeUARTTX	PinMode	= 4
-	PinModeUARTRX	PinMode	= 5
-
-	// for I2C
-	PinModeI2CSCL	PinMode	= 6
-	PinModeI2CSDA	PinMode	= 7
-
-	// for SPI
-	PinModeSPICLK	PinMode	= 8
-	PinModeSPISDO	PinMode	= 9
-	PinModeSPISDI	PinMode	= 10
-
-	// for analog/ADC
-	PinInputAnalog	PinMode	= 11
-)
-```
-
-
-
-```go
-const (
-	PA0	= portA + 0
-	PA1	= portA + 1
-	PA2	= portA + 2
-	PA3	= portA + 3
-	PA4	= portA + 4
-	PA5	= portA + 5
-	PA6	= portA + 6
-	PA7	= portA + 7
-	PA8	= portA + 8
-	PA9	= portA + 9
-	PA10	= portA + 10
-	PA11	= portA + 11
-	PA12	= portA + 12
-	PA13	= portA + 13
-	PA14	= portA + 14
-	PA15	= portA + 15
-
-	PB0	= portB + 0
-	PB1	= portB + 1
-	PB2	= portB + 2
-	PB3	= portB + 3
-	PB4	= portB + 4
-	PB5	= portB + 5
-	PB6	= portB + 6
-	PB7	= portB + 7
-	PB8	= portB + 8
-	PB9	= portB + 9
-	PB10	= portB + 10
-	PB11	= portB + 11
-	PB12	= portB + 12
-	PB13	= portB + 13
-	PB14	= portB + 14
-	PB15	= portB + 15
-
-	PC0	= portC + 0
-	PC1	= portC + 1
-	PC2	= portC + 2
-	PC3	= portC + 3
-	PC4	= portC + 4
-	PC5	= portC + 5
-	PC6	= portC + 6
-	PC7	= portC + 7
-	PC8	= portC + 8
-	PC9	= portC + 9
-	PC10	= portC + 10
-	PC11	= portC + 11
-	PC12	= portC + 12
-	PC13	= portC + 13
-	PC14	= portC + 14
-	PC15	= portC + 15
-
-	PD0	= portD + 0
-	PD1	= portD + 1
-	PD2	= portD + 2
-	PD3	= portD + 3
-	PD4	= portD + 4
-	PD5	= portD + 5
-	PD6	= portD + 6
-	PD7	= portD + 7
-	PD8	= portD + 8
-	PD9	= portD + 9
-	PD10	= portD + 10
-	PD11	= portD + 11
-	PD12	= portD + 12
-	PD13	= portD + 13
-	PD14	= portD + 14
-	PD15	= portD + 15
-
-	PE0	= portE + 0
-	PE1	= portE + 1
-	PE2	= portE + 2
-	PE3	= portE + 3
-	PE4	= portE + 4
-	PE5	= portE + 5
-	PE6	= portE + 6
-	PE7	= portE + 7
-	PE8	= portE + 8
-	PE9	= portE + 9
-	PE10	= portE + 10
-	PE11	= portE + 11
-	PE12	= portE + 12
-	PE13	= portE + 13
-	PE14	= portE + 14
-	PE15	= portE + 15
-
-	PH0	= portH + 0
-	PH1	= portH + 1
-)
-```
-
-
-
-```go
-const (
-	Mode0	= 0
-	Mode1	= 1
-	Mode2	= 2
-	Mode3	= 3
-)
-```
-
-SPI phase and polarity configs CPOL and CPHA
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART0	= UART{
-		Buffer:			NewRingBuffer(),
-		Bus:			stm32.USART2,
-		AltFuncSelector:	stm32.AF7_USART1_2_3,
-	}
-	UART1	= &UART0
-)
-```
-
-
-
-```go
-var (
-	SPI0	= SPI{
-		Bus:			stm32.SPI1,
-		AltFuncSelector:	stm32.AF5_SPI1_SPI2,
-	}
-	SPI1	= &SPI0
-)
-```
-
-Since the first interface is named SPI1, both SPI0 and SPI1 refer to SPI1.
-TODO: implement SPI2 and SPI3.
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration
-
-
-### func (Pin) ConfigureAltFunc
-
-```go
-func (p Pin) ConfigureAltFunc(config PinConfig, altFunc stm32.AltFunc)
-```
-
-Configure this pin with the given configuration including alternate
- function mapping if necessary.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetAltFunc
-
-```go
-func (p Pin) SetAltFunc(af stm32.AltFunc)
-```
-
-SetAltFunc maps the given alternative function to the I/O pin
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus		*stm32.SPI_Type
-	AltFuncSelector	stm32.AltFunc
-}
-```
-
-SPI on the STM32Fxxx using MODER / alternate function pins
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the STM32 SPI1 interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer		*RingBuffer
-	Bus		*stm32.USART_Type
-	Interrupt	interrupt.Interrupt
-	AltFuncSelector	stm32.AltFunc
-}
-```
-
-UART representation
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART. Defer to chip-specific
-routines for calculation
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/stm32f4disco.md b/content/microcontrollers/machine/stm32f4disco.md
deleted file mode 100644
index ae4440a7..00000000
--- a/content/microcontrollers/machine/stm32f4disco.md
+++ /dev/null
@@ -1,649 +0,0 @@
-
----
-title: stm32f4disco
----
-
-
-## Constants
-
-```go
-const (
-	LED		= LED_BUILTIN
-	LED1		= LED_GREEN
-	LED2		= LED_ORANGE
-	LED3		= LED_RED
-	LED4		= LED_BLUE
-	LED_BUILTIN	= LED_GREEN
-	LED_GREEN	= PD12
-	LED_ORANGE	= PD13
-	LED_RED		= PD14
-	LED_BLUE	= PD15
-)
-```
-
-
-
-```go
-const (
-	UART_TX_PIN	= PA2
-	UART_RX_PIN	= PA3
-)
-```
-
-UART pins
-
-
-```go
-const (
-	SPI1_SCK_PIN	= PA5
-	SPI1_SDI_PIN	= PA6
-	SPI1_SDO_PIN	= PA7
-	SPI0_SCK_PIN	= SPI1_SCK_PIN
-	SPI0_SDI_PIN	= SPI1_SDI_PIN
-	SPI0_SDO_PIN	= SPI1_SDO_PIN
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	MEMS_ACCEL_CS	= PE3
-	MEMS_ACCEL_INT1	= PE0
-	MEMS_ACCEL_INT2	= PE1
-)
-```
-
-MEMs accelerometer
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	// Mode Flag
-	PinOutput		PinMode	= 0
-	PinInput		PinMode	= PinInputFloating
-	PinInputFloating	PinMode	= 1
-	PinInputPulldown	PinMode	= 2
-	PinInputPullup		PinMode	= 3
-
-	// for UART
-	PinModeUARTTX	PinMode	= 4
-	PinModeUARTRX	PinMode	= 5
-
-	// for I2C
-	PinModeI2CSCL	PinMode	= 6
-	PinModeI2CSDA	PinMode	= 7
-
-	// for SPI
-	PinModeSPICLK	PinMode	= 8
-	PinModeSPISDO	PinMode	= 9
-	PinModeSPISDI	PinMode	= 10
-
-	// for analog/ADC
-	PinInputAnalog	PinMode	= 11
-)
-```
-
-
-
-```go
-const (
-	PA0	= portA + 0
-	PA1	= portA + 1
-	PA2	= portA + 2
-	PA3	= portA + 3
-	PA4	= portA + 4
-	PA5	= portA + 5
-	PA6	= portA + 6
-	PA7	= portA + 7
-	PA8	= portA + 8
-	PA9	= portA + 9
-	PA10	= portA + 10
-	PA11	= portA + 11
-	PA12	= portA + 12
-	PA13	= portA + 13
-	PA14	= portA + 14
-	PA15	= portA + 15
-
-	PB0	= portB + 0
-	PB1	= portB + 1
-	PB2	= portB + 2
-	PB3	= portB + 3
-	PB4	= portB + 4
-	PB5	= portB + 5
-	PB6	= portB + 6
-	PB7	= portB + 7
-	PB8	= portB + 8
-	PB9	= portB + 9
-	PB10	= portB + 10
-	PB11	= portB + 11
-	PB12	= portB + 12
-	PB13	= portB + 13
-	PB14	= portB + 14
-	PB15	= portB + 15
-
-	PC0	= portC + 0
-	PC1	= portC + 1
-	PC2	= portC + 2
-	PC3	= portC + 3
-	PC4	= portC + 4
-	PC5	= portC + 5
-	PC6	= portC + 6
-	PC7	= portC + 7
-	PC8	= portC + 8
-	PC9	= portC + 9
-	PC10	= portC + 10
-	PC11	= portC + 11
-	PC12	= portC + 12
-	PC13	= portC + 13
-	PC14	= portC + 14
-	PC15	= portC + 15
-
-	PD0	= portD + 0
-	PD1	= portD + 1
-	PD2	= portD + 2
-	PD3	= portD + 3
-	PD4	= portD + 4
-	PD5	= portD + 5
-	PD6	= portD + 6
-	PD7	= portD + 7
-	PD8	= portD + 8
-	PD9	= portD + 9
-	PD10	= portD + 10
-	PD11	= portD + 11
-	PD12	= portD + 12
-	PD13	= portD + 13
-	PD14	= portD + 14
-	PD15	= portD + 15
-
-	PE0	= portE + 0
-	PE1	= portE + 1
-	PE2	= portE + 2
-	PE3	= portE + 3
-	PE4	= portE + 4
-	PE5	= portE + 5
-	PE6	= portE + 6
-	PE7	= portE + 7
-	PE8	= portE + 8
-	PE9	= portE + 9
-	PE10	= portE + 10
-	PE11	= portE + 11
-	PE12	= portE + 12
-	PE13	= portE + 13
-	PE14	= portE + 14
-	PE15	= portE + 15
-
-	PH0	= portH + 0
-	PH1	= portH + 1
-)
-```
-
-
-
-```go
-const (
-	Mode0	= 0
-	Mode1	= 1
-	Mode2	= 2
-	Mode3	= 3
-)
-```
-
-SPI phase and polarity configs CPOL and CPHA
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART0	= UART{
-		Buffer:			NewRingBuffer(),
-		Bus:			stm32.USART2,
-		AltFuncSelector:	stm32.AF7_USART1_2_3,
-	}
-	UART1	= &UART0
-)
-```
-
-
-
-```go
-var (
-	SPI0	= SPI{
-		Bus:			stm32.SPI1,
-		AltFuncSelector:	stm32.AF5_SPI1_SPI2,
-	}
-	SPI1	= &SPI0
-)
-```
-
-Since the first interface is named SPI1, both SPI0 and SPI1 refer to SPI1.
-TODO: implement SPI2 and SPI3.
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration
-
-
-### func (Pin) ConfigureAltFunc
-
-```go
-func (p Pin) ConfigureAltFunc(config PinConfig, altFunc stm32.AltFunc)
-```
-
-Configure this pin with the given configuration including alternate
- function mapping if necessary.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetAltFunc
-
-```go
-func (p Pin) SetAltFunc(af stm32.AltFunc)
-```
-
-SetAltFunc maps the given alternative function to the I/O pin
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus		*stm32.SPI_Type
-	AltFuncSelector	stm32.AltFunc
-}
-```
-
-SPI on the STM32Fxxx using MODER / alternate function pins
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the STM32 SPI1 interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer		*RingBuffer
-	Bus		*stm32.USART_Type
-	Interrupt	interrupt.Interrupt
-	AltFuncSelector	stm32.AltFunc
-}
-```
-
-UART representation
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART. Defer to chip-specific
-routines for calculation
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/trinket-m0.md b/content/microcontrollers/machine/trinket-m0.md
deleted file mode 100644
index b863f9cd..00000000
--- a/content/microcontrollers/machine/trinket-m0.md
+++ /dev/null
@@ -1,1597 +0,0 @@
-
----
-title: trinket-m0
----
-
-
-## Constants
-
-```go
-const (
-	PA00	Pin	= 0
-	PA01	Pin	= 1
-	PA02	Pin	= 2
-	PA03	Pin	= 3
-	PA04	Pin	= 4
-	PA05	Pin	= 5
-	PA06	Pin	= 6
-	PA07	Pin	= 7
-	PA08	Pin	= 8
-	PA09	Pin	= 9
-	PA10	Pin	= 10
-	PA11	Pin	= 11
-	PA12	Pin	= 12
-	PA13	Pin	= 13
-	PA14	Pin	= 14
-	PA15	Pin	= 15
-	PA16	Pin	= 16
-	PA17	Pin	= 17
-	PA18	Pin	= 18
-	PA19	Pin	= 19
-	PA20	Pin	= 20
-	PA21	Pin	= 21
-	PA22	Pin	= 22
-	PA23	Pin	= 23
-	PA24	Pin	= 24
-	PA25	Pin	= 25
-	PA26	Pin	= 26
-	PA27	Pin	= 27
-	PA28	Pin	= 28
-	PA29	Pin	= 29
-	PA30	Pin	= 30
-	PA31	Pin	= 31
-	PB00	Pin	= 32
-	PB01	Pin	= 33
-	PB02	Pin	= 34
-	PB03	Pin	= 35
-	PB04	Pin	= 36
-	PB05	Pin	= 37
-	PB06	Pin	= 38
-	PB07	Pin	= 39
-	PB08	Pin	= 40
-	PB09	Pin	= 41
-	PB10	Pin	= 42
-	PB11	Pin	= 43
-	PB12	Pin	= 44
-	PB13	Pin	= 45
-	PB14	Pin	= 46
-	PB15	Pin	= 47
-	PB16	Pin	= 48
-	PB17	Pin	= 49
-	PB18	Pin	= 50
-	PB19	Pin	= 51
-	PB20	Pin	= 52
-	PB21	Pin	= 53
-	PB22	Pin	= 54
-	PB23	Pin	= 55
-	PB24	Pin	= 56
-	PB25	Pin	= 57
-	PB26	Pin	= 58
-	PB27	Pin	= 59
-	PB28	Pin	= 60
-	PB29	Pin	= 61
-	PB30	Pin	= 62
-	PB31	Pin	= 63
-)
-```
-
-Hardware pins
-
-
-```go
-const RESET_MAGIC_VALUE = 0xf01669ef
-```
-
-used to reset into bootloader
-
-
-```go
-const (
-	D0	= PA08	// PWM available
-	D1	= PA02
-	D2	= PA09	// PWM available
-	D3	= PA07	// PWM available / UART0 RX
-	D4	= PA06	// PWM available / UART0 TX
-	D13	= PA10	// LED
-)
-```
-
-GPIO Pins
-
-
-```go
-const (
-	A0	= D1
-	A1	= D2
-	A2	= D0
-	A3	= D3
-	A4	= D4
-)
-```
-
-Analog pins
-
-
-```go
-const (
-	LED = D13
-)
-```
-
-
-
-```go
-const (
-	USBCDC_DM_PIN	= PA24
-	USBCDC_DP_PIN	= PA25
-)
-```
-
-UART0 aka USBCDC pins
-
-
-```go
-const (
-	UART_TX_PIN	= D4
-	UART_RX_PIN	= D3
-)
-```
-
-UART1 pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	= D3
-	SPI0_SDO_PIN	= D4
-	SPI0_SDI_PIN	= D2
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	SDA_PIN	= D0	// SDA
-	SCL_PIN	= D2	// SCL
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	I2S_SCK_PIN	= PA10
-	I2S_SD_PIN	= PA08
-	I2S_WS_PIN	= NoPin	// TODO: figure out what this is on Trinket M0.
-)
-```
-
-I2S pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const (
-	I2SModeSource	I2SMode	= iota
-	I2SModeReceiver
-	I2SModePDM
-)
-```
-
-
-
-```go
-const (
-	I2StandardPhilips	I2SStandard	= iota
-	I2SStandardMSB
-	I2SStandardLSB
-)
-```
-
-
-
-```go
-const (
-	I2SClockSourceInternal	I2SClockSource	= iota
-	I2SClockSourceExternal
-)
-```
-
-
-
-```go
-const (
-	I2SDataFormatDefault	I2SDataFormat	= 0
-	I2SDataFormat8bit			= 8
-	I2SDataFormat16bit			= 16
-	I2SDataFormat24bit			= 24
-	I2SDataFormat32bit			= 32
-)
-```
-
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinAnalog	PinMode	= 1
-	PinSERCOM	PinMode	= 2
-	PinSERCOMAlt	PinMode	= 3
-	PinTimer	PinMode	= 4
-	PinTimerAlt	PinMode	= 5
-	PinCom		PinMode	= 6
-	//PinAC_CLK        PinMode = 7
-	PinDigital		PinMode	= 8
-	PinInput		PinMode	= 9
-	PinInputPullup		PinMode	= 10
-	PinOutput		PinMode	= 11
-	PinPWM			PinMode	= PinTimer
-	PinPWMAlt		PinMode	= PinTimerAlt
-	PinInputPulldown	PinMode	= 12
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
-	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
-	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	Mode0	= 0
-	Mode1	= 1
-	Mode2	= 2
-	Mode3	= 3
-)
-```
-
-SPI phase and polarity configs CPOL and CPHA
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART1 = UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	sam.SERCOM0_USART,
-		SERCOM:	0,
-	}
-)
-```
-
-UART1 on the Trinket M0.
-
-
-```go
-var (
-	SPI0 = SPI{
-		Bus:	sam.SERCOM0_SPI,
-		SERCOM:	0,
-	}
-)
-```
-
-SPI on the Trinket M0.
-
-
-```go
-var (
-	I2C0 = I2C{
-		Bus:	sam.SERCOM2_I2CM,
-		SERCOM:	2,
-	}
-)
-```
-
-I2C on the Trinket M0.
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	// UART0 is actually a USB CDC interface.
-	UART0 = USBCDC{Buffer: NewRingBuffer()}
-)
-```
-
-
-
-```go
-var (
-	DAC0 = DAC{}
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-Return the current CPU frequency in hertz.
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the PWM interface.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-### func ResetProcessor
-
-```go
-func ResetProcessor()
-```
-
-ResetProcessor should perform a system reset in preperation
-to switch to the bootloader to flash new firmware.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure()
-```
-
-Configure configures a ADCPin to be able to be used to read data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin, in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DAC
-
-```go
-type DAC struct {
-}
-```
-
-DAC on the SAMD21.
-
-
-
-### func (DAC) Configure
-
-```go
-func (dac DAC) Configure(config DACConfig)
-```
-
-Configure the DAC.
-output pin must already be configured.
-
-
-### func (DAC) Set
-
-```go
-func (dac DAC) Set(value uint16) error
-```
-
-Set writes a single 16-bit value to the DAC.
-Since the ATSAMD21 only has a 10-bit DAC, the passed-in value will be scaled down.
-
-
-
-
-## type DACConfig
-
-```go
-type DACConfig struct {
-}
-```
-
-DACConfig placeholder for future expansion.
-
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus	*sam.SERCOM_I2CM_Type
-	SERCOM	uint8
-}
-```
-
-I2C on the SAMD21.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig) error
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) SetBaudRate
-
-```go
-func (i2c I2C) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the I2C.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteByte
-
-```go
-func (i2c I2C) WriteByte(data byte) error
-```
-
-WriteByte writes a single byte to the I2C bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type I2S
-
-```go
-type I2S struct {
-	Bus *sam.I2S_Type
-}
-```
-
-I2S
-
-
-
-### func (I2S) Close
-
-```go
-func (i2s I2S) Close() error
-```
-
-Close the I2S bus.
-
-
-### func (I2S) Configure
-
-```go
-func (i2s I2S) Configure(config I2SConfig)
-```
-
-Configure is used to configure the I2S interface. You must call this
-before you can use the I2S bus.
-
-
-### func (I2S) Read
-
-```go
-func (i2s I2S) Read(p []uint32) (n int, err error)
-```
-
-Read data from the I2S bus into the provided slice.
-The I2S bus must already have been configured correctly.
-
-
-### func (I2S) Write
-
-```go
-func (i2s I2S) Write(p []uint32) (n int, err error)
-```
-
-Write data to the I2S bus from the provided slice.
-The I2S bus must already have been configured correctly.
-
-
-
-
-## type I2SClockSource
-
-```go
-type I2SClockSource uint8
-```
-
-
-
-
-
-
-## type I2SConfig
-
-```go
-type I2SConfig struct {
-	SCK		Pin
-	WS		Pin
-	SD		Pin
-	Mode		I2SMode
-	Standard	I2SStandard
-	ClockSource	I2SClockSource
-	DataFormat	I2SDataFormat
-	AudioFrequency	uint32
-	MainClockOutput	bool
-	Stereo		bool
-}
-```
-
-All fields are optional and may not be required or used on a particular platform.
-
-
-
-
-
-## type I2SDataFormat
-
-```go
-type I2SDataFormat uint8
-```
-
-
-
-
-
-
-## type I2SMode
-
-```go
-type I2SMode uint8
-```
-
-
-
-
-
-
-## type I2SStandard
-
-```go
-type I2SStandard uint8
-```
-
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure() error
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus	*sam.SERCOM_SPI_Type
-	SERCOM	uint8
-}
-```
-
-SPI
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig) error
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer		*RingBuffer
-	Bus		*sam.SERCOM_USART_Type
-	SERCOM		uint8
-	Interrupt	interrupt.Interrupt
-}
-```
-
-UART on the SAMD21.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig) error
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer *RingBuffer
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the SAMD21.
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (USBCDC) Configure
-
-```go
-func (usbcdc USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/wasi.md b/content/microcontrollers/machine/wasi.md
deleted file mode 100644
index 4941c680..00000000
--- a/content/microcontrollers/machine/wasi.md
+++ /dev/null
@@ -1,509 +0,0 @@
-
----
-title: wasi
----
-
-
-## Constants
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput	PinMode	= iota
-	PinOutput
-	PinInputPullup
-	PinInputPulldown
-)
-```
-
-
-
-```go
-const (
-	Mode0	= 0
-	Mode1	= 1
-	Mode2	= 2
-	Mode3	= 3
-)
-```
-
-SPI phase and polarity configs CPOL and CPHA
-
-
-
-
-
-## Variables
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	SPI0	= SPI{0}
-	I2C0	= I2C{0}
-	UART0	= UART{0}
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC enables support for ADC peripherals.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM enables support for PWM peripherals.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (adc ADC) Configure()
-```
-
-Configure configures an ADC pin to be able to be used to read data.
-
-
-### func (ADC) Get
-
-```go
-func (adc ADC) Get() uint16
-```
-
-Get reads the current analog value from this ADC peripheral.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus uint8
-}
-```
-
-I2C is a generic implementation of the Inter-IC communication protocol.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure() error
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(value bool)
-```
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus uint8
-}
-```
-
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	Mode		uint8
-}
-```
-
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Bus uint8
-}
-```
-
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the UART.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(b byte) error
-```
-
-WriteByte writes a single byte to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/wasm.md b/content/microcontrollers/machine/wasm.md
deleted file mode 100644
index c4bc0593..00000000
--- a/content/microcontrollers/machine/wasm.md
+++ /dev/null
@@ -1,509 +0,0 @@
-
----
-title: wasm
----
-
-
-## Constants
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput	PinMode	= iota
-	PinOutput
-	PinInputPullup
-	PinInputPulldown
-)
-```
-
-
-
-```go
-const (
-	Mode0	= 0
-	Mode1	= 1
-	Mode2	= 2
-	Mode3	= 3
-)
-```
-
-SPI phase and polarity configs CPOL and CPHA
-
-
-
-
-
-## Variables
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	SPI0	= SPI{0}
-	I2C0	= I2C{0}
-	UART0	= UART{0}
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC enables support for ADC peripherals.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM enables support for PWM peripherals.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (adc ADC) Configure()
-```
-
-Configure configures an ADC pin to be able to be used to read data.
-
-
-### func (ADC) Get
-
-```go
-func (adc ADC) Get() uint16
-```
-
-Get reads the current analog value from this ADC peripheral.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus uint8
-}
-```
-
-I2C is a generic implementation of the Inter-IC communication protocol.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure() error
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(value bool)
-```
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus uint8
-}
-```
-
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	Mode		uint8
-}
-```
-
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Bus uint8
-}
-```
-
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the UART.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(b byte) error
-```
-
-WriteByte writes a single byte to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/wioterminal.md b/content/microcontrollers/machine/wioterminal.md
deleted file mode 100644
index 6698c6e9..00000000
--- a/content/microcontrollers/machine/wioterminal.md
+++ /dev/null
@@ -1,1980 +0,0 @@
-
----
-title: wioterminal
----
-
-
-## Constants
-
-```go
-const RESET_MAGIC_VALUE = 0xf01669ef
-```
-
-used to reset into bootloader
-
-
-```go
-const (
-	ADC0	= A0
-	ADC1	= A1
-	ADC2	= A2
-	ADC3	= A3
-	ADC4	= A4
-	ADC5	= A5
-	ADC6	= A6
-	ADC7	= A7
-	ADC8	= A8
-
-	LED	= PIN_LED
-	BUTTON	= BUTTON_1
-)
-```
-
-
-
-```go
-const (
-
-	// LEDs
-	PIN_LED_13	= PA15
-	PIN_LED_RXL	= PA15
-	PIN_LED_TXL	= PA15
-	PIN_LED		= PIN_LED_13
-	PIN_LED2	= PIN_LED_RXL
-	PIN_LED3	= PIN_LED_TXL
-	LED_BUILTIN	= PIN_LED_13
-	PIN_NEOPIXEL	= PA15
-
-	//Digital PINs
-	D0	= PB08
-	D1	= PB09
-	D2	= PA07
-	D3	= PB04
-	D4	= PB05
-	D5	= PB06
-	D6	= PA04
-	D7	= PB07
-	D8	= PA06
-
-	//Analog PINs
-	A0	= PB08	// ADC/AIN[0]
-	A1	= PB09	// ADC/AIN[2]
-	A2	= PA07	// ADC/AIN[3]
-	A3	= PB04	// ADC/AIN[4]
-	A4	= PB05	// ADC/AIN[5]
-	A5	= PB06	// ADC/AIN[10]
-	A6	= PA04	// ADC/AIN[10]
-	A7	= PB07	// ADC/AIN[10]
-	A8	= PA06	// ADC/AIN[10]
-
-	//PIN DEFINE FOR RPI
-	BCM0	= PA13	// I2C Wire1
-	BCM1	= PA12	// I2C Wire1
-	BCM2	= PA17	// I2C Wire2
-	BCM3	= PA16	// I2C Wire2
-	BCM4	= PB14	// GCLK
-	BCM5	= PB12	// GCLK
-	BCM6	= PB13	// GCLK
-	BCM7	= PA05	// DAC1
-	BCM8	= PB01	// SPI SS
-	BCM9	= PB00	// SPI SDI
-	BCM10	= PB02	// SPI SDO
-	BCM11	= PB03	// SPI SCK
-	BCM12	= PB06
-	BCM13	= PA07
-	BCM14	= PB27	// UART Serial1
-	BCM15	= PB26	// UART Serial1
-	BCM16	= PB07
-	BCM17	= PA02	// DAC0
-	BCM18	= PB28	// FPC Digital & AD pins
-	BCM19	= PA20	// WIO_IR
-	BCM20	= PA21	// I2S SDO
-	BCM21	= PA22	// I2S SDI
-	BCM22	= PB09
-	BCM23	= PA07
-	BCM24	= PB04
-	BCM25	= PB05
-	BCM26	= PA06
-	BCM27	= PB08
-
-	// FPC NEW DEFINE
-	FPC1	= PB28	// FPC Digital & AD pins
-	FPC2	= PB17
-	FPC3	= PB29
-	FPC4	= PA14
-	FPC5	= PC01
-	FPC6	= PC02
-	FPC7	= PC03
-	FPC8	= PC04
-	FPC9	= PC31
-	FPC10	= PD00
-
-	// RPI Analog RPIs
-	RPI_A0	= PB08
-	RPI_A1	= PB09
-	RPI_A2	= PA07
-	RPI_A3	= PB04
-	RPI_A4	= PB05
-	RPI_A5	= PB06
-	RPI_A6	= PA04
-	RPI_A7	= PB07
-	RPI_A8	= PA06
-
-	PIN_DAC0	= PA02
-	PIN_DAC1	= PA05
-
-	// USB
-	PIN_USB_DM		= PA24
-	PIN_USB_DP		= PA25
-	PIN_USB_HOST_ENABLE	= PA27
-
-	// BUTTON
-	BUTTON_1	= PC26
-	BUTTON_2	= PC27
-	BUTTON_3	= PC28
-	WIO_KEY_A	= PC26
-	WIO_KEY_B	= PC27
-	WIO_KEY_C	= PC28
-
-	// SWITCH
-	SWITCH_X	= PD20
-	SWITCH_Y	= PD12
-	SWITCH_Z	= PD09
-	SWITCH_B	= PD08
-	SWITCH_U	= PD10
-
-	WIO_5S_UP	= PD20
-	WIO_5S_LEFT	= PD12
-	WIO_5S_RIGHT	= PD09
-	WIO_5S_DOWN	= PD08
-	WIO_5S_PRESS	= PD10
-
-	// IRQ0 : RTL8720D
-	IRQ0	= PC20
-
-	// BUZZER_CTR
-	BUZZER_CTR	= PD11
-	WIO_BUZZER	= PD11
-
-	// MIC_INPUT
-	MIC_INPUT	= PC30
-	WIO_MIC		= PC30
-
-	// GCLK
-	GCLK0	= PB14
-	GCLK1	= PB12
-	GCLK2	= PB13
-
-	// Serial interfaces
-	// Serial1
-	PIN_SERIAL1_RX	= PB27
-	PIN_SERIAL1_TX	= PB26
-
-	// Serial2 : RTL8720D
-	PIN_SERIAL2_RX	= PC23
-	PIN_SERIAL2_TX	= PC22
-
-	// Wire Interfaces
-	// I2C Wire2
-	// I2C1
-	PIN_WIRE_SDA	= PA17
-	PIN_WIRE_SCL	= PA16
-	SDA		= PIN_WIRE_SDA
-	SCL		= PIN_WIRE_SCL
-
-	// I2C Wire1
-	// I2C0 : LIS3DHTR and ATECC608
-	PIN_WIRE1_SDA	= PA13
-	PIN_WIRE1_SCL	= PA12
-
-	SDA1	= PIN_WIRE1_SDA
-	SCL1	= PIN_WIRE1_SCL
-
-	PIN_GYROSCOPE_WIRE_SDA	= PIN_WIRE1_SDA
-	PIN_GYROSCOPE_WIRE_SCL	= PIN_WIRE1_SCL
-	GYROSCOPE_INT1		= PC21
-
-	WIO_LIS3DH_SDA	= PIN_WIRE1_SDA
-	WIO_LIS3DH_SCL	= PIN_WIRE1_SCL
-	WIO_LIS3DH_INT	= PC21
-
-	// SPI
-	PIN_SPI_SDI	= PB00
-	PIN_SPI_SDO	= PB02
-	PIN_SPI_SCK	= PB03
-	PIN_SPI_SS	= PB01
-
-	SS	= PIN_SPI_SS
-	SDO	= PIN_SPI_SDO
-	SDI	= PIN_SPI_SDI
-	SCK	= PIN_SPI_SCK
-
-	// SPI1 RTL8720D_SPI
-	PIN_SPI1_SDI	= PC24
-	PIN_SPI1_SDO	= PB24
-	PIN_SPI1_SCK	= PB25
-	PIN_SPI1_SS	= PC25
-
-	SS1	= PIN_SPI1_SS
-	SDO1	= PIN_SPI1_SDO
-	SDI1	= PIN_SPI1_SDI
-	SCK1	= PIN_SPI1_SCK
-
-	// SPI2 SD_SPI
-	PIN_SPI2_SDI	= PC18
-	PIN_SPI2_SDO	= PC16
-	PIN_SPI2_SCK	= PC17
-	PIN_SPI2_SS	= PC19
-
-	SS2	= PIN_SPI2_SS
-	SDO2	= PIN_SPI2_SDO
-	SDI2	= PIN_SPI2_SDI
-	SCK2	= PIN_SPI2_SCK
-
-	// SPI3 LCD_SPI
-	PIN_SPI3_SDI	= PB18
-	PIN_SPI3_SDO	= PB19
-	PIN_SPI3_SCK	= PB20
-	PIN_SPI3_SS	= PB21
-
-	SS3	= PIN_SPI3_SS
-	SDO3	= PIN_SPI3_SDO
-	SDI3	= PIN_SPI3_SDI
-	SCK3	= PIN_SPI3_SCK
-
-	// Needed for SD library
-	SDCARD_SDI_PIN	= PIN_SPI2_SDI
-	SDCARD_SDO_PIN	= PIN_SPI2_SDO
-	SDCARD_SCK_PIN	= PIN_SPI2_SCK
-	SDCARD_SS_PIN	= PIN_SPI2_SS
-	SDCARD_DET_PIN	= PD21
-
-	LCD_SDI_PIN	= PIN_SPI3_SDI
-	LCD_SDO_PIN	= PIN_SPI3_SDO
-	LCD_SCK_PIN	= PIN_SPI3_SCK
-	LCD_SS_PIN	= PIN_SPI3_SS
-	LCD_DC		= PC06
-	LCD_RESET	= PC07
-	LCD_BACKLIGHT	= PC05
-
-	// 4 WIRE LCD TOUCH
-	LCD_XL	= PC10
-	LCD_YU	= PC11
-	LCD_XR	= PC12
-	LCD_YD	= PC13
-
-	// Needed for RTL8720D
-	RTL8720D_SDI_PIN	= PIN_SPI1_SDI
-	RTL8720D_SDO_PIN	= PIN_SPI1_SDO
-	RTL8720D_SCK_PIN	= PIN_SPI1_SCK
-	RTL8720D_SS_PIN		= PIN_SPI1_SS
-
-	//QSPI Pins
-	PIN_QSPI_IO0	= PA08
-	PIN_QSPI_IO1	= PA09
-	PIN_QSPI_IO2	= PA10
-	PIN_QSPI_IO3	= PA11
-	PIN_QSPI_SCK	= PB10
-	PIN_QSPI_CS	= PB11
-
-	// I2S Interfaces
-	PIN_I2S_FS	= PA20
-	PIN_I2S_SCK	= PB16
-	PIN_I2S_SDO	= PA22
-	PIN_I2S_SDI	= PA21
-
-	I2S_LRCLK	= PA20
-	I2S_BLCK	= PB16
-	I2S_SDOUT	= PA22
-	I2S_SDIN	= PA21
-
-	// RTL8720D Interfaces
-	RTL8720D_CHIP_PU	= PA18
-	RTL8720D_GPIO0		= PA19	// SYNC
-
-	// SWD
-	SWDCLK	= PA30
-	SWDIO	= PA31
-	SWO	= PB30
-
-	// light sensor
-	WIO_LIGHT	= PD01
-
-	// ir sensor
-	WIO_IR	= PB31
-
-	// OUTPUT_CTR
-	OUTPUT_CTR_5V	= PC14
-	OUTPUT_CTR_3V3	= PC15
-)
-```
-
-
-
-```go
-const (
-	USBCDC_DM_PIN	= PIN_USB_DM
-	USBCDC_DP_PIN	= PIN_USB_DP
-)
-```
-
-UART0 aka USBCDC pins
-
-
-```go
-const (
-	UART_TX_PIN	= PIN_SERIAL1_TX
-	UART_RX_PIN	= PIN_SERIAL1_RX
-)
-```
-
-UART1 pins
-
-
-```go
-const (
-	UART2_TX_PIN	= PIN_SERIAL2_TX
-	UART2_RX_PIN	= PIN_SERIAL2_RX
-)
-```
-
-UART2 pins RTL8720D
-
-
-```go
-const (
-	SDA0_PIN	= PIN_WIRE_SDA	// SDA: SERCOM3/PAD[0]
-	SCL0_PIN	= PIN_WIRE_SCL	// SCL: SERCOM3/PAD[1]
-
-	SDA1_PIN	= PIN_WIRE1_SDA	// SDA: SERCOM4/PAD[0]
-	SCL1_PIN	= PIN_WIRE1_SCL	// SCL: SERCOM4/PAD[1]
-
-	SDA_PIN	= SDA0_PIN
-	SCL_PIN	= SCL0_PIN
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	= SCK	// SCK:  SERCOM5/PAD[1]
-	SPI0_SDO_PIN	= SDO	// SDO: SERCOM5/PAD[0]
-	SPI0_SDI_PIN	= SDI	// SDI: SERCOM5/PAD[2]
-
-	// RTL8720D
-	SPI1_SCK_PIN	= SCK1	// SCK:  SERCOM0/PAD[1]
-	SPI1_SDO_PIN	= SDO1	// SDO: SERCOM0/PAD[0]
-	SPI1_SDI_PIN	= SDI1	// SDI: SERCOM0/PAD[2]
-
-	// SD
-	SPI2_SCK_PIN	= SCK2	// SCK:  SERCOM6/PAD[1]
-	SPI2_SDO_PIN	= SDO2	// SDO: SERCOM6/PAD[0]
-	SPI2_SDI_PIN	= SDI2	// SDI: SERCOM6/PAD[2]
-
-	// LCD
-	SPI3_SCK_PIN	= SCK3	// SCK:  SERCOM7/PAD[1]
-	SPI3_SDO_PIN	= SDO3	// SDO: SERCOM7/PAD[3]
-	SPI3_SDI_PIN	= SDI3	// SDI: SERCOM7/PAD[2]
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const (
-	I2SModeSource	I2SMode	= iota
-	I2SModeReceiver
-	I2SModePDM
-)
-```
-
-
-
-```go
-const (
-	I2StandardPhilips	I2SStandard	= iota
-	I2SStandardMSB
-	I2SStandardLSB
-)
-```
-
-
-
-```go
-const (
-	I2SClockSourceInternal	I2SClockSource	= iota
-	I2SClockSourceExternal
-)
-```
-
-
-
-```go
-const (
-	I2SDataFormatDefault	I2SDataFormat	= 0
-	I2SDataFormat8bit			= 8
-	I2SDataFormat16bit			= 16
-	I2SDataFormat24bit			= 24
-	I2SDataFormat32bit			= 32
-)
-```
-
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinAnalog		PinMode	= 1
-	PinSERCOM		PinMode	= 2
-	PinSERCOMAlt		PinMode	= 3
-	PinTimer		PinMode	= 4
-	PinTimerAlt		PinMode	= 5
-	PinTCCPDEC		PinMode	= 6
-	PinCom			PinMode	= 7
-	PinSDHC			PinMode	= 8
-	PinI2S			PinMode	= 9
-	PinPCC			PinMode	= 10
-	PinGMAC			PinMode	= 11
-	PinACCLK		PinMode	= 12
-	PinCCL			PinMode	= 13
-	PinDigital		PinMode	= 14
-	PinInput		PinMode	= 15
-	PinInputPullup		PinMode	= 16
-	PinOutput		PinMode	= 17
-	PinPWME			PinMode	= PinTimer
-	PinPWMF			PinMode	= PinTimerAlt
-	PinPWMG			PinMode	= PinTCCPDEC
-	PinInputPulldown	PinMode	= 18
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
-	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
-	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	PA00	Pin	= 0
-	PA01	Pin	= 1
-	PA02	Pin	= 2
-	PA03	Pin	= 3
-	PA04	Pin	= 4
-	PA05	Pin	= 5
-	PA06	Pin	= 6
-	PA07	Pin	= 7
-	PA08	Pin	= 8
-	PA09	Pin	= 9
-	PA10	Pin	= 10
-	PA11	Pin	= 11
-	PA12	Pin	= 12
-	PA13	Pin	= 13
-	PA14	Pin	= 14
-	PA15	Pin	= 15
-	PA16	Pin	= 16
-	PA17	Pin	= 17
-	PA18	Pin	= 18
-	PA19	Pin	= 19
-	PA20	Pin	= 20
-	PA21	Pin	= 21
-	PA22	Pin	= 22
-	PA23	Pin	= 23
-	PA24	Pin	= 24
-	PA25	Pin	= 25
-	PA26	Pin	= 26
-	PA27	Pin	= 27
-	PA28	Pin	= 28
-	PA29	Pin	= 29
-	PA30	Pin	= 30
-	PA31	Pin	= 31
-	PB00	Pin	= 32
-	PB01	Pin	= 33
-	PB02	Pin	= 34
-	PB03	Pin	= 35
-	PB04	Pin	= 36
-	PB05	Pin	= 37
-	PB06	Pin	= 38
-	PB07	Pin	= 39
-	PB08	Pin	= 40
-	PB09	Pin	= 41
-	PB10	Pin	= 42
-	PB11	Pin	= 43
-	PB12	Pin	= 44
-	PB13	Pin	= 45
-	PB14	Pin	= 46
-	PB15	Pin	= 47
-	PB16	Pin	= 48
-	PB17	Pin	= 49
-	PB18	Pin	= 50
-	PB19	Pin	= 51
-	PB20	Pin	= 52
-	PB21	Pin	= 53
-	PB22	Pin	= 54
-	PB23	Pin	= 55
-	PB24	Pin	= 56
-	PB25	Pin	= 57
-	PB26	Pin	= 58
-	PB27	Pin	= 59
-	PB28	Pin	= 60
-	PB29	Pin	= 61
-	PB30	Pin	= 62
-	PB31	Pin	= 63
-	PC00	Pin	= 64
-	PC01	Pin	= 65
-	PC02	Pin	= 66
-	PC03	Pin	= 67
-	PC04	Pin	= 68
-	PC05	Pin	= 69
-	PC06	Pin	= 70
-	PC07	Pin	= 71
-	PC08	Pin	= 72
-	PC09	Pin	= 73
-	PC10	Pin	= 74
-	PC11	Pin	= 75
-	PC12	Pin	= 76
-	PC13	Pin	= 77
-	PC14	Pin	= 78
-	PC15	Pin	= 79
-	PC16	Pin	= 80
-	PC17	Pin	= 81
-	PC18	Pin	= 82
-	PC19	Pin	= 83
-	PC20	Pin	= 84
-	PC21	Pin	= 85
-	PC22	Pin	= 86
-	PC23	Pin	= 87
-	PC24	Pin	= 88
-	PC25	Pin	= 89
-	PC26	Pin	= 90
-	PC27	Pin	= 91
-	PC28	Pin	= 92
-	PC29	Pin	= 93
-	PC30	Pin	= 94
-	PC31	Pin	= 95
-	PD00	Pin	= 96
-	PD01	Pin	= 97
-	PD02	Pin	= 98
-	PD03	Pin	= 99
-	PD04	Pin	= 100
-	PD05	Pin	= 101
-	PD06	Pin	= 102
-	PD07	Pin	= 103
-	PD08	Pin	= 104
-	PD09	Pin	= 105
-	PD10	Pin	= 106
-	PD11	Pin	= 107
-	PD12	Pin	= 108
-	PD13	Pin	= 109
-	PD14	Pin	= 110
-	PD15	Pin	= 111
-	PD16	Pin	= 112
-	PD17	Pin	= 113
-	PD18	Pin	= 114
-	PD19	Pin	= 115
-	PD20	Pin	= 116
-	PD21	Pin	= 117
-	PD22	Pin	= 118
-	PD23	Pin	= 119
-	PD24	Pin	= 120
-	PD25	Pin	= 121
-	PD26	Pin	= 122
-	PD27	Pin	= 123
-	PD28	Pin	= 124
-	PD29	Pin	= 125
-	PD30	Pin	= 126
-	PD31	Pin	= 127
-)
-```
-
-Hardware pins
-
-
-```go
-const (
-	// SERCOM_FREQ_REF is always reference frequency on SAMD51 regardless of CPU speed.
-	SERCOM_FREQ_REF	= 48000000
-
-	// Default rise time in nanoseconds, based on 4.7K ohm pull up resistors
-	riseTimeNanoseconds	= 125
-
-	// wire bus states
-	wireUnknownState	= 0
-	wireIdleState		= 1
-	wireOwnerState		= 2
-	wireBusyState		= 3
-
-	// wire commands
-	wireCmdNoAction		= 0
-	wireCmdRepeatStart	= 1
-	wireCmdRead		= 2
-	wireCmdStop		= 3
-)
-```
-
-
-
-```go
-const (
-	QSPI_SCK	= PB10
-	QSPI_CS		= PB11
-	QSPI_DATA0	= PA08
-	QSPI_DATA1	= PA09
-	QSPI_DATA2	= PA10
-	QSPI_DATA3	= PA11
-)
-```
-
-The QSPI peripheral on ATSAMD51 is only available on the following pins
-
-
-```go
-const HSRAM_SIZE = 0x00030000
-```
-
-
-
-```go
-const (
-	Mode0	= 0
-	Mode1	= 1
-	Mode2	= 2
-	Mode3	= 3
-)
-```
-
-SPI phase and polarity configs CPOL and CPHA
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART1	= UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	sam.SERCOM2_USART_INT,
-		SERCOM:	2,
-	}
-
-	// RTL8720D
-	UART2	= UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	sam.SERCOM1_USART_INT,
-		SERCOM:	1,
-	}
-)
-```
-
-
-
-```go
-var (
-	I2C0	= I2C{
-		Bus:	sam.SERCOM4_I2CM,
-		SERCOM:	4,
-	}
-
-	I2C1	= I2C{
-		Bus:	sam.SERCOM4_I2CM,
-		SERCOM:	4,
-	}
-)
-```
-
-I2C on the Wio Terminal
-
-
-```go
-var (
-	SPI0	= SPI{
-		Bus:	sam.SERCOM5_SPIM,
-		SERCOM:	5,
-	}
-
-	// RTL8720D
-	SPI1	= SPI{
-		Bus:	sam.SERCOM0_SPIM,
-		SERCOM:	0,
-	}
-
-	// SD
-	SPI2	= SPI{
-		Bus:	sam.SERCOM6_SPIM,
-		SERCOM:	6,
-	}
-
-	// LCD
-	SPI3	= SPI{
-		Bus:	sam.SERCOM7_SPIM,
-		SERCOM:	7,
-	}
-)
-```
-
-SPI on the Wio Terminal
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	// UART0 is actually a USB CDC interface.
-	UART0 = USBCDC{Buffer: NewRingBuffer()}
-)
-```
-
-
-
-```go
-var (
-	DAC0 = DAC{}
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the PWM interface.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-### func ResetProcessor
-
-```go
-func ResetProcessor()
-```
-
-ResetProcessor should perform a system reset in preparation
-to switch to the bootloader to flash new firmware.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure()
-```
-
-Configure configures a ADCPin to be able to be used to read data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin, in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DAC
-
-```go
-type DAC struct {
-}
-```
-
-DAC on the SAMD51.
-
-
-
-### func (DAC) Configure
-
-```go
-func (dac DAC) Configure(config DACConfig)
-```
-
-Configure the DAC.
-output pin must already be configured.
-
-
-### func (DAC) Set
-
-```go
-func (dac DAC) Set(value uint16) error
-```
-
-Set writes a single 16-bit value to the DAC.
-Since the ATSAMD51 only has a 12-bit DAC, the passed-in value will be scaled down.
-
-
-
-
-## type DACConfig
-
-```go
-type DACConfig struct {
-}
-```
-
-DACConfig placeholder for future expansion.
-
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus	*sam.SERCOM_I2CM_Type
-	SERCOM	uint8
-}
-```
-
-I2C on the SAMD51.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig) error
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) SetBaudRate
-
-```go
-func (i2c I2C) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the I2C.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteByte
-
-```go
-func (i2c I2C) WriteByte(data byte) error
-```
-
-WriteByte writes a single byte to the I2C bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type I2SClockSource
-
-```go
-type I2SClockSource uint8
-```
-
-
-
-
-
-
-## type I2SConfig
-
-```go
-type I2SConfig struct {
-	SCK		Pin
-	WS		Pin
-	SD		Pin
-	Mode		I2SMode
-	Standard	I2SStandard
-	ClockSource	I2SClockSource
-	DataFormat	I2SDataFormat
-	AudioFrequency	uint32
-	MainClockOutput	bool
-	Stereo		bool
-}
-```
-
-All fields are optional and may not be required or used on a particular platform.
-
-
-
-
-
-## type I2SDataFormat
-
-```go
-type I2SDataFormat uint8
-```
-
-
-
-
-
-
-## type I2SMode
-
-```go
-type I2SMode uint8
-```
-
-
-
-
-
-
-## type I2SStandard
-
-```go
-type I2SStandard uint8
-```
-
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure() error
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-### func (Pin) Toggle
-
-```go
-func (p Pin) Toggle()
-```
-
-Toggle switches an output pin from low to high or from high to low.
-Warning: only use this on an output pin!
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus	*sam.SERCOM_SPIM_Type
-	SERCOM	uint8
-}
-```
-
-SPI
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig) error
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer		*RingBuffer
-	Bus		*sam.SERCOM_USART_INT_Type
-	SERCOM		uint8
-	Interrupt	interrupt.Interrupt	// RXC interrupt
-}
-```
-
-UART on the SAMD51.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig) error
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer *RingBuffer
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the SAMD21.
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (USBCDC) Configure
-
-```go
-func (usbcdc USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/machine/x9pro.md b/content/microcontrollers/machine/x9pro.md
deleted file mode 100644
index f90d1ddf..00000000
--- a/content/microcontrollers/machine/x9pro.md
+++ /dev/null
@@ -1,696 +0,0 @@
-
----
-title: x9pro
----
-
-
-## Constants
-
-```go
-const (
-	LED		Pin	= 4	// HR LED pin
-	UART_TX_PIN	Pin	= NoPin
-	UART_RX_PIN	Pin	= NoPin
-	SCL_PIN		Pin	= NoPin
-	SDA_PIN		Pin	= NoPin
-	SPI0_SCK_PIN	Pin	= 18
-	SPI0_SDI_PIN	Pin	= 19
-	SPI0_SDO_PIN	Pin	= 20
-)
-```
-
-https://hackaday.io/project/144350-hacking-wearables-for-mental-health-and-more/details
-
-
-```go
-const (
-	OLED_CS		Pin	= 15	// chip select
-	OLED_RES	Pin	= 14	// reset pin
-	OLED_DC		Pin	= 13	// data/command
-	OLED_SCK	Pin	= 12	// SPI clock
-	OLED_SDO	Pin	= 11	// SPI SDO (chip-out, peripheral-in)
-	OLED_LED_POW	Pin	= 16
-	OLED_IC_POW	Pin	= 17
-)
-```
-
-LCD pins.
-
-
-```go
-const HasLowFrequencyCrystal = true
-```
-
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinInput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Input << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Connect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-	PinInputPullup		PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pullup << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinInputPulldown	PinMode	= PinInput | (nrf.GPIO_PIN_CNF_PULL_Pulldown << nrf.GPIO_PIN_CNF_PULL_Pos)
-	PinOutput		PinMode	= (nrf.GPIO_PIN_CNF_DIR_Output << nrf.GPIO_PIN_CNF_DIR_Pos) | (nrf.GPIO_PIN_CNF_INPUT_Disconnect << nrf.GPIO_PIN_CNF_INPUT_Pos)
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_LoToHi
-	PinFalling	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_HiToLo
-	PinToggle	PinChange	= nrf.GPIOTE_CONFIG_POLARITY_Toggle
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-
-
-
-## Variables
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-```go
-var (
-	// NRF_UART0 is the hardware UART on the NRF SoC.
-	NRF_UART0 = UART{Buffer: NewRingBuffer()}
-)
-```
-
-UART
-
-
-```go
-var (
-	I2C0	= I2C{Bus: nrf.TWI0}
-	I2C1	= I2C{Bus: nrf.TWI1}
-)
-```
-
-There are 2 I2C interfaces on the NRF.
-
-
-```go
-var (
-	SPI0	= SPI{Bus: nrf.SPI0}
-	SPI1	= SPI{Bus: nrf.SPI1}
-)
-```
-
-There are 2 SPI interfaces on the NRF5x.
-
-
-```go
-var (
-	UART0 = NRF_UART0
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the registers needed for ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the registers needed for PWM.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure()
-```
-
-Configure configures an ADC pin to be able to read analog data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin in the range 0..0xffff.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus *nrf.TWI_Type
-}
-```
-
-I2C on the NRF.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig)
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) (err error)
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure() error
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus *nrf.SPI_Type
-}
-```
-
-SPI on the NRF.
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig)
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer *RingBuffer
-}
-```
-
-UART on the NRF.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig)
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
diff --git a/content/microcontrollers/machine/xiao.md b/content/microcontrollers/machine/xiao.md
deleted file mode 100644
index b46d0ef7..00000000
--- a/content/microcontrollers/machine/xiao.md
+++ /dev/null
@@ -1,1621 +0,0 @@
-
----
-title: xiao
----
-
-
-## Constants
-
-```go
-const (
-	PA00	Pin	= 0
-	PA01	Pin	= 1
-	PA02	Pin	= 2
-	PA03	Pin	= 3
-	PA04	Pin	= 4
-	PA05	Pin	= 5
-	PA06	Pin	= 6
-	PA07	Pin	= 7
-	PA08	Pin	= 8
-	PA09	Pin	= 9
-	PA10	Pin	= 10
-	PA11	Pin	= 11
-	PA12	Pin	= 12
-	PA13	Pin	= 13
-	PA14	Pin	= 14
-	PA15	Pin	= 15
-	PA16	Pin	= 16
-	PA17	Pin	= 17
-	PA18	Pin	= 18
-	PA19	Pin	= 19
-	PA20	Pin	= 20
-	PA21	Pin	= 21
-	PA22	Pin	= 22
-	PA23	Pin	= 23
-	PA24	Pin	= 24
-	PA25	Pin	= 25
-	PA26	Pin	= 26
-	PA27	Pin	= 27
-	PA28	Pin	= 28
-	PA29	Pin	= 29
-	PA30	Pin	= 30
-	PA31	Pin	= 31
-	PB00	Pin	= 32
-	PB01	Pin	= 33
-	PB02	Pin	= 34
-	PB03	Pin	= 35
-	PB04	Pin	= 36
-	PB05	Pin	= 37
-	PB06	Pin	= 38
-	PB07	Pin	= 39
-	PB08	Pin	= 40
-	PB09	Pin	= 41
-	PB10	Pin	= 42
-	PB11	Pin	= 43
-	PB12	Pin	= 44
-	PB13	Pin	= 45
-	PB14	Pin	= 46
-	PB15	Pin	= 47
-	PB16	Pin	= 48
-	PB17	Pin	= 49
-	PB18	Pin	= 50
-	PB19	Pin	= 51
-	PB20	Pin	= 52
-	PB21	Pin	= 53
-	PB22	Pin	= 54
-	PB23	Pin	= 55
-	PB24	Pin	= 56
-	PB25	Pin	= 57
-	PB26	Pin	= 58
-	PB27	Pin	= 59
-	PB28	Pin	= 60
-	PB29	Pin	= 61
-	PB30	Pin	= 62
-	PB31	Pin	= 63
-)
-```
-
-Hardware pins
-
-
-```go
-const RESET_MAGIC_VALUE = 0xf01669ef
-```
-
-used to reset into bootloader
-
-
-```go
-const (
-	D0	= PA02	// can be used for PWM or DAC
-	D1	= PA04	// PWM available
-	D2	= PA10	// PWM available
-	D3	= PA11	// PWM available
-	D4	= PA08	// can be used for PWM or I2C SDA
-	D5	= PA09	// can be used for PWM or I2C SCL
-	D6	= PB08	// can be used for PWM or UART1 TX
-	D7	= PB09	// can be used for PWM or UART1 RX
-	D8	= PA07	// can be used for PWM or SPI SCK
-	D9	= PA05	// can be used for PWM or SPI SDI
-	D10	= PA06	// can be used for PWM or SPI SDO
-)
-```
-
-GPIO Pins
-
-
-```go
-const (
-	A0	= PA02	// ADC/AIN[0]
-	A1	= PA04	// ADC/AIN[4]
-	A2	= PA10	// ADC/AIN[18]
-	A3	= PA11	// ADC/AIN[19]
-	A4	= PA08	// ADC/AIN[16]
-	A5	= PA09	// ADC/AIN[17]
-	A6	= PB08	// ADC/AIN[2]
-	A7	= PB09	// ADC/AIN[3]
-	A8	= PA07	// ADC/AIN[7]
-	A9	= PA05	// ADC/AIN[6]
-	A10	= PA06	// ADC/AIN[5]
-)
-```
-
-Analog pins
-
-
-```go
-const (
-	LED	= PA17
-	LED_RXL	= PA18
-	LED_TXL	= PA19
-	LED2	= LED_RXL
-	LED3	= LED_TXL
-)
-```
-
-
-
-```go
-const (
-	USBCDC_DM_PIN	= PA24
-	USBCDC_DP_PIN	= PA25
-)
-```
-
-UART0 aka USBCDC pins
-
-
-```go
-const (
-	UART_TX_PIN	= D6
-	UART_RX_PIN	= D7
-)
-```
-
-UART1 pins
-
-
-```go
-const (
-	SDA_PIN	= PA08	// SDA: SERCOM2/PAD[0]
-	SCL_PIN	= PA09	// SCL: SERCOM2/PAD[1]
-)
-```
-
-I2C pins
-
-
-```go
-const (
-	SPI0_SCK_PIN	= PA07	// SCK: SERCOM0/PAD[3]
-	SPI0_SDO_PIN	= PA06	// SDO: SERCOM0/PAD[2]
-	SPI0_SDI_PIN	= PA05	// SDI: SERCOM0/PAD[1]
-)
-```
-
-SPI pins
-
-
-```go
-const (
-	I2S_SCK_PIN	= PA10
-	I2S_SD_PIN	= PA08
-	I2S_WS_PIN	= NoPin	// TODO: figure out what this is on Xiao
-)
-```
-
-I2S pins
-
-
-```go
-const (
-	TWI_FREQ_100KHZ	= 100000
-	TWI_FREQ_400KHZ	= 400000
-)
-```
-
-TWI_FREQ is the I2C bus speed. Normally either 100 kHz, or 400 kHz for high-speed bus.
-
-
-```go
-const (
-	I2SModeSource	I2SMode	= iota
-	I2SModeReceiver
-	I2SModePDM
-)
-```
-
-
-
-```go
-const (
-	I2StandardPhilips	I2SStandard	= iota
-	I2SStandardMSB
-	I2SStandardLSB
-)
-```
-
-
-
-```go
-const (
-	I2SClockSourceInternal	I2SClockSource	= iota
-	I2SClockSourceExternal
-)
-```
-
-
-
-```go
-const (
-	I2SDataFormatDefault	I2SDataFormat	= 0
-	I2SDataFormat8bit			= 8
-	I2SDataFormat16bit			= 16
-	I2SDataFormat24bit			= 24
-	I2SDataFormat32bit			= 32
-)
-```
-
-
-
-```go
-const NoPin = Pin(0xff)
-```
-
-NoPin explicitly indicates "not a pin". Use this pin if you want to leave one
-of the pins in a peripheral unconfigured (if supported by the hardware).
-
-
-```go
-const (
-	PinAnalog	PinMode	= 1
-	PinSERCOM	PinMode	= 2
-	PinSERCOMAlt	PinMode	= 3
-	PinTimer	PinMode	= 4
-	PinTimerAlt	PinMode	= 5
-	PinCom		PinMode	= 6
-	//PinAC_CLK        PinMode = 7
-	PinDigital		PinMode	= 8
-	PinInput		PinMode	= 9
-	PinInputPullup		PinMode	= 10
-	PinOutput		PinMode	= 11
-	PinPWM			PinMode	= PinTimer
-	PinPWMAlt		PinMode	= PinTimerAlt
-	PinInputPulldown	PinMode	= 12
-)
-```
-
-
-
-```go
-const (
-	PinRising	PinChange	= sam.EIC_CONFIG_SENSE0_RISE
-	PinFalling	PinChange	= sam.EIC_CONFIG_SENSE0_FALL
-	PinToggle	PinChange	= sam.EIC_CONFIG_SENSE0_BOTH
-)
-```
-
-Pin change interrupt constants for SetInterrupt.
-
-
-```go
-const (
-	Mode0	= 0
-	Mode1	= 1
-	Mode2	= 2
-	Mode3	= 3
-)
-```
-
-SPI phase and polarity configs CPOL and CPHA
-
-
-
-
-
-## Variables
-
-```go
-var (
-	UART1 = UART{
-		Buffer:	NewRingBuffer(),
-		Bus:	sam.SERCOM4_USART,
-		SERCOM:	4,
-	}
-)
-```
-
-UART1 on the Xiao
-
-
-```go
-var (
-	I2C0 = I2C{
-		Bus:	sam.SERCOM2_I2CM,
-		SERCOM:	2,
-	}
-)
-```
-
-I2C on the Xiao
-
-
-```go
-var (
-	SPI0 = SPI{
-		Bus:	sam.SERCOM0_SPI,
-		SERCOM:	0,
-	}
-)
-```
-
-SPI on the Xiao
-
-
-```go
-var (
-	I2S0 = I2S{Bus: sam.I2S}
-)
-```
-
-I2S on the Xiao
-
-
-```go
-var (
-	ErrInvalidInputPin	= errors.New("machine: invalid input pin")
-	ErrInvalidOutputPin	= errors.New("machine: invalid output pin")
-	ErrInvalidClockPin	= errors.New("machine: invalid clock pin")
-	ErrInvalidDataPin	= errors.New("machine: invalid data pin")
-	ErrNoPinChangeChannel	= errors.New("machine: no channel available for pin interrupt")
-)
-```
-
-
-
-```go
-var (
-	// UART0 is actually a USB CDC interface.
-	UART0 = USBCDC{Buffer: NewRingBuffer()}
-)
-```
-
-
-
-```go
-var (
-	DAC0 = DAC{}
-)
-```
-
-
-
-```go
-var (
-	ErrTxInvalidSliceSize = errors.New("SPI write and read slices must be same size")
-)
-```
-
-
-
-
-
-
-### func CPUFrequency
-
-```go
-func CPUFrequency() uint32
-```
-
-Return the current CPU frequency in hertz.
-
-
-### func InitADC
-
-```go
-func InitADC()
-```
-
-InitADC initializes the ADC.
-
-
-### func InitPWM
-
-```go
-func InitPWM()
-```
-
-InitPWM initializes the PWM interface.
-
-
-### func NewACMFunctionalDescriptor
-
-```go
-func NewACMFunctionalDescriptor(subtype, d0 uint8) ACMFunctionalDescriptor
-```
-
-NewACMFunctionalDescriptor returns a new USB ACMFunctionalDescriptor.
-
-
-### func NewCDCCSInterfaceDescriptor
-
-```go
-func NewCDCCSInterfaceDescriptor(subtype, d0, d1 uint8) CDCCSInterfaceDescriptor
-```
-
-NewCDCCSInterfaceDescriptor returns a new USB CDCCSInterfaceDescriptor.
-
-
-### func NewCDCDescriptor
-
-```go
-func NewCDCDescriptor(i IADDescriptor, c InterfaceDescriptor,
-	h CDCCSInterfaceDescriptor,
-	cm ACMFunctionalDescriptor,
-	fd CDCCSInterfaceDescriptor,
-	callm CMFunctionalDescriptor,
-	ci EndpointDescriptor,
-	di InterfaceDescriptor,
-	outp EndpointDescriptor,
-	inp EndpointDescriptor) CDCDescriptor
-```
-
-
-
-### func NewCMFunctionalDescriptor
-
-```go
-func NewCMFunctionalDescriptor(subtype, d0, d1 uint8) CMFunctionalDescriptor
-```
-
-NewCMFunctionalDescriptor returns a new USB CMFunctionalDescriptor.
-
-
-### func NewConfigDescriptor
-
-```go
-func NewConfigDescriptor(totalLength uint16, interfaces uint8) ConfigDescriptor
-```
-
-NewConfigDescriptor returns a new USB ConfigDescriptor.
-
-
-### func NewDeviceDescriptor
-
-```go
-func NewDeviceDescriptor(class, subClass, proto, packetSize0 uint8, vid, pid, version uint16, im, ip, is, configs uint8) DeviceDescriptor
-```
-
-NewDeviceDescriptor returns a USB DeviceDescriptor.
-
-
-### func NewEndpointDescriptor
-
-```go
-func NewEndpointDescriptor(addr, attr uint8, packetSize uint16, interval uint8) EndpointDescriptor
-```
-
-NewEndpointDescriptor returns a new USB EndpointDescriptor.
-
-
-### func NewIADDescriptor
-
-```go
-func NewIADDescriptor(firstInterface, count, class, subClass, protocol uint8) IADDescriptor
-```
-
-NewIADDescriptor returns a new USB IADDescriptor.
-
-
-### func NewInterfaceDescriptor
-
-```go
-func NewInterfaceDescriptor(n, numEndpoints, class, subClass, protocol uint8) InterfaceDescriptor
-```
-
-NewInterfaceDescriptor returns a new USB InterfaceDescriptor.
-
-
-### func NewRingBuffer
-
-```go
-func NewRingBuffer() *RingBuffer
-```
-
-NewRingBuffer returns a new ring buffer.
-
-
-### func ResetProcessor
-
-```go
-func ResetProcessor()
-```
-
-ResetProcessor should perform a system reset in preperation
-to switch to the bootloader to flash new firmware.
-
-
-
-
-## type ACMFunctionalDescriptor
-
-```go
-type ACMFunctionalDescriptor struct {
-	len		uint8
-	dtype		uint8	// 0x24
-	subtype		uint8	// 1
-	bmCapabilities	uint8
-}
-```
-
-ACMFunctionalDescriptor is a Abstract Control Model (ACM) USB descriptor.
-
-
-
-### func (ACMFunctionalDescriptor) Bytes
-
-```go
-func (d ACMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the ACMFunctionalDescriptor data.
-
-
-
-
-## type ADC
-
-```go
-type ADC struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (ADC) Configure
-
-```go
-func (a ADC) Configure()
-```
-
-Configure configures a ADCPin to be able to be used to read data.
-
-
-### func (ADC) Get
-
-```go
-func (a ADC) Get() uint16
-```
-
-Get returns the current value of a ADC pin, in the range 0..0xffff.
-
-
-
-
-## type CDCCSInterfaceDescriptor
-
-```go
-type CDCCSInterfaceDescriptor struct {
-	len	uint8	// 5
-	dtype	uint8	// 0x24
-	subtype	uint8
-	d0	uint8
-	d1	uint8
-}
-```
-
-CDCCSInterfaceDescriptor is a CDC CS interface descriptor.
-
-
-
-### func (CDCCSInterfaceDescriptor) Bytes
-
-```go
-func (d CDCCSInterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCCSInterfaceDescriptor data.
-
-
-
-
-## type CDCDescriptor
-
-```go
-type CDCDescriptor struct {
-	//	IAD
-	iad	IADDescriptor	// Only needed on compound device
-
-	//	Control
-	cif	InterfaceDescriptor
-	header	CDCCSInterfaceDescriptor
-
-	// CDC control
-	controlManagement	ACMFunctionalDescriptor		// ACM
-	functionalDescriptor	CDCCSInterfaceDescriptor	// CDC_UNION
-	callManagement		CMFunctionalDescriptor		// Call Management
-	cifin			EndpointDescriptor
-
-	//	CDC Data
-	dif	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-CDCDescriptor is the Communication Device Class (CDC) descriptor.
-
-
-
-### func (CDCDescriptor) Bytes
-
-```go
-func (d CDCDescriptor) Bytes() []byte
-```
-
-Bytes returns CDCDescriptor data.
-
-
-
-
-## type CMFunctionalDescriptor
-
-```go
-type CMFunctionalDescriptor struct {
-	bFunctionLength		uint8
-	bDescriptorType		uint8	// 0x24
-	bDescriptorSubtype	uint8	// 1
-	bmCapabilities		uint8
-	bDataInterface		uint8
-}
-```
-
-CMFunctionalDescriptor is the functional descriptor general format.
-
-
-
-### func (CMFunctionalDescriptor) Bytes
-
-```go
-func (d CMFunctionalDescriptor) Bytes() []byte
-```
-
-Bytes returns the CMFunctionalDescriptor data.
-
-
-
-
-## type ConfigDescriptor
-
-```go
-type ConfigDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 2
-	wTotalLength		uint16	// total length
-	bNumInterfaces		uint8
-	bConfigurationValue	uint8
-	iConfiguration		uint8
-	bmAttributes		uint8
-	bMaxPower		uint8
-}
-```
-
-ConfigDescriptor implements the standard USB configuration descriptor.
-
-Table 9-10. Standard Configuration Descriptor
-bLength, bDescriptorType, wTotalLength, bNumInterfaces, bConfigurationValue, iConfiguration
-bmAttributes, bMaxPower
-
-
-
-### func (ConfigDescriptor) Bytes
-
-```go
-func (d ConfigDescriptor) Bytes() []byte
-```
-
-Bytes returns ConfigDescriptor data.
-
-
-
-
-## type DAC
-
-```go
-type DAC struct {
-}
-```
-
-DAC on the SAMD21.
-
-
-
-### func (DAC) Configure
-
-```go
-func (dac DAC) Configure(config DACConfig)
-```
-
-Configure the DAC.
-output pin must already be configured.
-
-
-### func (DAC) Set
-
-```go
-func (dac DAC) Set(value uint16) error
-```
-
-Set writes a single 16-bit value to the DAC.
-Since the ATSAMD21 only has a 10-bit DAC, the passed-in value will be scaled down.
-
-
-
-
-## type DACConfig
-
-```go
-type DACConfig struct {
-}
-```
-
-DACConfig placeholder for future expansion.
-
-
-
-
-
-## type DeviceDescriptor
-
-```go
-type DeviceDescriptor struct {
-	bLength			uint8	// 18
-	bDescriptorType		uint8	// 1 USB_DEVICE_DESCRIPTOR_TYPE
-	bcdUSB			uint16	// 0x200
-	bDeviceClass		uint8
-	bDeviceSubClass		uint8
-	bDeviceProtocol		uint8
-	bMaxPacketSize0		uint8	// Packet 0
-	idVendor		uint16
-	idProduct		uint16
-	bcdDevice		uint16	// 0x100
-	iManufacturer		uint8
-	iProduct		uint8
-	iSerialNumber		uint8
-	bNumConfigurations	uint8
-}
-```
-
-DeviceDescriptor implements the USB standard device descriptor.
-
-Table 9-8. Standard Device Descriptor
-bLength, bDescriptorType, bcdUSB, bDeviceClass, bDeviceSubClass, bDeviceProtocol, bMaxPacketSize0,
-   idVendor, idProduct, bcdDevice, iManufacturer, iProduct, iSerialNumber, bNumConfigurations */
-
-
-
-### func (DeviceDescriptor) Bytes
-
-```go
-func (d DeviceDescriptor) Bytes() []byte
-```
-
-Bytes returns DeviceDescriptor data
-
-
-
-
-## type EndpointDescriptor
-
-```go
-type EndpointDescriptor struct {
-	bLength			uint8	// 7
-	bDescriptorType		uint8	// 5
-	bEndpointAddress	uint8
-	bmAttributes		uint8
-	wMaxPacketSize		uint16
-	bInterval		uint8
-}
-```
-
-EndpointDescriptor implements the standard USB endpoint descriptor.
-
-Table 9-13. Standard Endpoint Descriptor
-bLength, bDescriptorType, bEndpointAddress, bmAttributes, wMaxPacketSize, bInterval
-
-
-
-### func (EndpointDescriptor) Bytes
-
-```go
-func (d EndpointDescriptor) Bytes() []byte
-```
-
-Bytes returns EndpointDescriptor data.
-
-
-
-
-## type I2C
-
-```go
-type I2C struct {
-	Bus	*sam.SERCOM_I2CM_Type
-	SERCOM	uint8
-}
-```
-
-I2C on the SAMD21.
-
-
-
-### func (I2C) Configure
-
-```go
-func (i2c I2C) Configure(config I2CConfig) error
-```
-
-Configure is intended to setup the I2C interface.
-
-
-### func (I2C) ReadRegister
-
-```go
-func (i2c I2C) ReadRegister(address uint8, register uint8, data []byte) error
-```
-
-ReadRegister transmits the register, restarts the connection as a read
-operation, and reads the response.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily read such registers. Also, it only works for devices
-with 7-bit addresses, which is the vast majority.
-
-
-### func (I2C) SetBaudRate
-
-```go
-func (i2c I2C) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the I2C.
-
-
-### func (I2C) Tx
-
-```go
-func (i2c I2C) Tx(addr uint16, w, r []byte) error
-```
-
-Tx does a single I2C transaction at the specified address.
-It clocks out the given address, writes the bytes in w, reads back len(r)
-bytes and stores them in r, and generates a stop condition on the bus.
-
-
-### func (I2C) WriteByte
-
-```go
-func (i2c I2C) WriteByte(data byte) error
-```
-
-WriteByte writes a single byte to the I2C bus.
-
-
-### func (I2C) WriteRegister
-
-```go
-func (i2c I2C) WriteRegister(address uint8, register uint8, data []byte) error
-```
-
-WriteRegister transmits first the register and then the data to the
-peripheral device.
-
-Many I2C-compatible devices are organized in terms of registers. This method
-is a shortcut to easily write to such registers. Also, it only works for
-devices with 7-bit addresses, which is the vast majority.
-
-
-
-
-## type I2CConfig
-
-```go
-type I2CConfig struct {
-	Frequency	uint32
-	SCL		Pin
-	SDA		Pin
-}
-```
-
-I2CConfig is used to store config info for I2C.
-
-
-
-
-
-## type I2S
-
-```go
-type I2S struct {
-	Bus *sam.I2S_Type
-}
-```
-
-I2S
-
-
-
-### func (I2S) Close
-
-```go
-func (i2s I2S) Close() error
-```
-
-Close the I2S bus.
-
-
-### func (I2S) Configure
-
-```go
-func (i2s I2S) Configure(config I2SConfig)
-```
-
-Configure is used to configure the I2S interface. You must call this
-before you can use the I2S bus.
-
-
-### func (I2S) Read
-
-```go
-func (i2s I2S) Read(p []uint32) (n int, err error)
-```
-
-Read data from the I2S bus into the provided slice.
-The I2S bus must already have been configured correctly.
-
-
-### func (I2S) Write
-
-```go
-func (i2s I2S) Write(p []uint32) (n int, err error)
-```
-
-Write data to the I2S bus from the provided slice.
-The I2S bus must already have been configured correctly.
-
-
-
-
-## type I2SClockSource
-
-```go
-type I2SClockSource uint8
-```
-
-
-
-
-
-
-## type I2SConfig
-
-```go
-type I2SConfig struct {
-	SCK		Pin
-	WS		Pin
-	SD		Pin
-	Mode		I2SMode
-	Standard	I2SStandard
-	ClockSource	I2SClockSource
-	DataFormat	I2SDataFormat
-	AudioFrequency	uint32
-	MainClockOutput	bool
-	Stereo		bool
-}
-```
-
-All fields are optional and may not be required or used on a particular platform.
-
-
-
-
-
-## type I2SDataFormat
-
-```go
-type I2SDataFormat uint8
-```
-
-
-
-
-
-
-## type I2SMode
-
-```go
-type I2SMode uint8
-```
-
-
-
-
-
-
-## type I2SStandard
-
-```go
-type I2SStandard uint8
-```
-
-
-
-
-
-
-## type IADDescriptor
-
-```go
-type IADDescriptor struct {
-	bLength			uint8	// 8
-	bDescriptorType		uint8	// 11
-	bFirstInterface		uint8
-	bInterfaceCount		uint8
-	bFunctionClass		uint8
-	bFunctionSubClass	uint8
-	bFunctionProtocol	uint8
-	iFunction		uint8
-}
-```
-
-IADDescriptor is an Interface Association Descriptor, which is used
-to bind 2 interfaces together in CDC composite device.
-
-Standard Interface Association Descriptor:
-bLength, bDescriptorType, bFirstInterface, bInterfaceCount, bFunctionClass, bFunctionSubClass,
-bFunctionProtocol, iFunction
-
-
-
-### func (IADDescriptor) Bytes
-
-```go
-func (d IADDescriptor) Bytes() []byte
-```
-
-Bytes returns IADDescriptor data.
-
-
-
-
-## type InterfaceDescriptor
-
-```go
-type InterfaceDescriptor struct {
-	bLength			uint8	// 9
-	bDescriptorType		uint8	// 4
-	bInterfaceNumber	uint8
-	bAlternateSetting	uint8
-	bNumEndpoints		uint8
-	bInterfaceClass		uint8
-	bInterfaceSubClass	uint8
-	bInterfaceProtocol	uint8
-	iInterface		uint8
-}
-```
-
-InterfaceDescriptor implements the standard USB interface descriptor.
-
-Table 9-12. Standard Interface Descriptor
-bLength, bDescriptorType, bInterfaceNumber, bAlternateSetting, bNumEndpoints, bInterfaceClass,
-bInterfaceSubClass, bInterfaceProtocol, iInterface
-
-
-
-### func (InterfaceDescriptor) Bytes
-
-```go
-func (d InterfaceDescriptor) Bytes() []byte
-```
-
-Bytes returns InterfaceDescriptor data.
-
-
-
-
-## type MSCDescriptor
-
-```go
-type MSCDescriptor struct {
-	msc	InterfaceDescriptor
-	in	EndpointDescriptor
-	out	EndpointDescriptor
-}
-```
-
-MSCDescriptor is not used yet.
-
-
-
-
-
-## type PWM
-
-```go
-type PWM struct {
-	Pin Pin
-}
-```
-
-
-
-
-### func (PWM) Configure
-
-```go
-func (pwm PWM) Configure() error
-```
-
-Configure configures a PWM pin for output.
-
-
-### func (PWM) Set
-
-```go
-func (pwm PWM) Set(value uint16)
-```
-
-Set turns on the duty cycle for a PWM pin using the provided value.
-
-
-
-
-## type Pin
-
-```go
-type Pin uint8
-```
-
-Pin is a single pin on a chip, which may be connected to other hardware
-devices. It can either be used directly as GPIO pin or it can be used in
-other peripherals like ADC, I2C, etc.
-
-
-
-### func (Pin) Configure
-
-```go
-func (p Pin) Configure(config PinConfig)
-```
-
-Configure this pin with the given configuration.
-
-
-### func (Pin) Get
-
-```go
-func (p Pin) Get() bool
-```
-
-Get returns the current value of a GPIO pin.
-
-
-### func (Pin) High
-
-```go
-func (p Pin) High()
-```
-
-High sets this GPIO pin to high, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to high that is not configured as an output pin.
-
-
-### func (Pin) Low
-
-```go
-func (p Pin) Low()
-```
-
-Low sets this GPIO pin to low, assuming it has been configured as an output
-pin. It is hardware dependent (and often undefined) what happens if you set a
-pin to low that is not configured as an output pin.
-
-
-### func (Pin) PortMaskClear
-
-```go
-func (p Pin) PortMaskClear() (*uint32, uint32)
-```
-
-Return the register and mask to disable a given port. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) PortMaskSet
-
-```go
-func (p Pin) PortMaskSet() (*uint32, uint32)
-```
-
-Return the register and mask to enable a given GPIO pin. This can be used to
-implement bit-banged drivers.
-
-
-### func (Pin) Set
-
-```go
-func (p Pin) Set(high bool)
-```
-
-Set the pin to high or low.
-Warning: only use this on an output pin!
-
-
-### func (Pin) SetInterrupt
-
-```go
-func (p Pin) SetInterrupt(change PinChange, callback func(Pin)) error
-```
-
-SetInterrupt sets an interrupt to be executed when a particular pin changes
-state. The pin should already be configured as an input, including a pull up
-or down if no external pull is provided.
-
-This call will replace a previously set callback on this pin. You can pass a
-nil func to unset the pin change interrupt. If you do so, the change
-parameter is ignored and can be set to any value (such as 0).
-
-
-
-
-## type PinChange
-
-```go
-type PinChange uint8
-```
-
-
-
-
-
-
-## type PinConfig
-
-```go
-type PinConfig struct {
-	Mode PinMode
-}
-```
-
-
-
-
-
-
-## type PinMode
-
-```go
-type PinMode uint8
-```
-
-
-
-
-
-
-## type RingBuffer
-
-```go
-type RingBuffer struct {
-	rxbuffer	[bufferSize]volatile.Register8
-	head		volatile.Register8
-	tail		volatile.Register8
-}
-```
-
-RingBuffer is ring buffer implementation inspired by post at
-https://www.embeddedrelated.com/showthread/comp.arch.embedded/77084-1.php
-
-
-
-### func (*RingBuffer) Clear
-
-```go
-func (rb *RingBuffer) Clear()
-```
-
-Clear resets the head and tail pointer to zero.
-
-
-### func (*RingBuffer) Get
-
-```go
-func (rb *RingBuffer) Get() (byte, bool)
-```
-
-Get returns a byte from the buffer. If the buffer is empty,
-the method will return a false as the second value.
-
-
-### func (*RingBuffer) Put
-
-```go
-func (rb *RingBuffer) Put(val byte) bool
-```
-
-Put stores a byte in the buffer. If the buffer is already
-full, the method will return false.
-
-
-### func (*RingBuffer) Used
-
-```go
-func (rb *RingBuffer) Used() uint8
-```
-
-Used returns how many bytes in buffer have been used.
-
-
-
-
-## type SPI
-
-```go
-type SPI struct {
-	Bus	*sam.SERCOM_SPI_Type
-	SERCOM	uint8
-}
-```
-
-SPI
-
-
-
-### func (SPI) Configure
-
-```go
-func (spi SPI) Configure(config SPIConfig) error
-```
-
-Configure is intended to setup the SPI interface.
-
-
-### func (SPI) Transfer
-
-```go
-func (spi SPI) Transfer(w byte) (byte, error)
-```
-
-Transfer writes/reads a single byte using the SPI interface.
-
-
-### func (SPI) Tx
-
-```go
-func (spi SPI) Tx(w, r []byte) error
-```
-
-Tx handles read/write operation for SPI interface. Since SPI is a syncronous write/read
-interface, there must always be the same number of bytes written as bytes read.
-The Tx method knows about this, and offers a few different ways of calling it.
-
-This form sends the bytes in tx buffer, putting the resulting bytes read into the rx buffer.
-Note that the tx and rx buffers must be the same size:
-
-		spi.Tx(tx, rx)
-
-This form sends the tx buffer, ignoring the result. Useful for sending "commands" that return zeros
-until all the bytes in the command packet have been received:
-
-		spi.Tx(tx, nil)
-
-This form sends zeros, putting the result into the rx buffer. Good for reading a "result packet":
-
-		spi.Tx(nil, rx)
-
-
-
-
-## type SPIConfig
-
-```go
-type SPIConfig struct {
-	Frequency	uint32
-	SCK		Pin
-	SDO		Pin
-	SDI		Pin
-	LSBFirst	bool
-	Mode		uint8
-}
-```
-
-SPIConfig is used to store config info for SPI.
-
-
-
-
-
-## type UART
-
-```go
-type UART struct {
-	Buffer		*RingBuffer
-	Bus		*sam.SERCOM_USART_Type
-	SERCOM		uint8
-	Interrupt	interrupt.Interrupt
-}
-```
-
-UART on the SAMD21.
-
-
-
-### func (UART) Buffered
-
-```go
-func (uart UART) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (UART) Configure
-
-```go
-func (uart UART) Configure(config UARTConfig) error
-```
-
-Configure the UART.
-
-
-### func (UART) Read
-
-```go
-func (uart UART) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (UART) ReadByte
-
-```go
-func (uart UART) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (UART) Receive
-
-```go
-func (uart UART) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (UART) SetBaudRate
-
-```go
-func (uart UART) SetBaudRate(br uint32)
-```
-
-SetBaudRate sets the communication speed for the UART.
-
-
-### func (UART) Write
-
-```go
-func (uart UART) Write(data []byte) (n int, err error)
-```
-
-Write data to the UART.
-
-
-### func (UART) WriteByte
-
-```go
-func (uart UART) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the UART.
-
-
-
-
-## type UARTConfig
-
-```go
-type UARTConfig struct {
-	BaudRate	uint32
-	TX		Pin
-	RX		Pin
-}
-```
-
-
-
-
-
-
-## type USBCDC
-
-```go
-type USBCDC struct {
-	Buffer *RingBuffer
-}
-```
-
-USBCDC is the USB CDC aka serial over USB interface on the SAMD21.
-
-
-
-### func (USBCDC) Buffered
-
-```go
-func (usbcdc USBCDC) Buffered() int
-```
-
-Buffered returns the number of bytes currently stored in the RX buffer.
-
-
-### func (USBCDC) Configure
-
-```go
-func (usbcdc USBCDC) Configure(config UARTConfig)
-```
-
-Configure the USB CDC interface. The config is here for compatibility with the UART interface.
-
-
-### func (USBCDC) DTR
-
-```go
-func (usbcdc USBCDC) DTR() bool
-```
-
-
-
-### func (USBCDC) RTS
-
-```go
-func (usbcdc USBCDC) RTS() bool
-```
-
-
-
-### func (USBCDC) Read
-
-```go
-func (usbcdc USBCDC) Read(data []byte) (n int, err error)
-```
-
-Read from the RX buffer.
-
-
-### func (USBCDC) ReadByte
-
-```go
-func (usbcdc USBCDC) ReadByte() (byte, error)
-```
-
-ReadByte reads a single byte from the RX buffer.
-If there is no data in the buffer, returns an error.
-
-
-### func (USBCDC) Receive
-
-```go
-func (usbcdc USBCDC) Receive(data byte)
-```
-
-Receive handles adding data to the UART's data buffer.
-Usually called by the IRQ handler for a machine.
-
-
-### func (USBCDC) Write
-
-```go
-func (usbcdc USBCDC) Write(data []byte) (n int, err error)
-```
-
-Write data to the USBCDC.
-
-
-### func (USBCDC) WriteByte
-
-```go
-func (usbcdc USBCDC) WriteByte(c byte) error
-```
-
-WriteByte writes a byte of data to the USB CDC interface.
-
-
-
-
diff --git a/content/microcontrollers/maixbit.md b/content/microcontrollers/maixbit.md
deleted file mode 100644
index 34aa946d..00000000
--- a/content/microcontrollers/maixbit.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "Sipeed MAix Bit"
-weight: 3
----
-
-The [Sipeed MAix Bit](https://www.seeedstudio.com/Sipeed-MAix-BiT-for-RISC-V-AI-IoT-p-2872.html) is a low-cost development board featuring the [Kendryte K210](https://canaan.io/product/kendryteai) [RISC-V](https://riscv.org/) (RV64GC) chip.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | NO | NO |
-| PWM      | YES | Not yet |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Sipeed MAix Bit](../machine/maixbit)
-
-## Flashing
-
-### Kflash.py
-
-Programs are loaded onto the MAix Bit using the `kflash.py` command line utility program. You must install this program before you will be able to flash the MAix Bit board with your TinyGo code.
-
-The latest version of the `kflash.py` can be installed using `pip3 install kflash`.
-
-- Plug your MAix Bit into your computer's USB port.
-- Build and flash your TinyGo program using `tinygo flash -target=maixbit [PATH TO YOUR PROGRAM]`
-
-## Troubleshooting
-
-You may get the following error when flashing the MAix Bit:
-
-```shell
-error: unable to locate a serial port
-```
-To resolve this, just specify the MAix Bit's serial port when flashing using `tinygo flash -target=maixbit -port=[MAIXBIT PORT] [PATH TO YOUR PROGRAM]`.
diff --git a/content/microcontrollers/metro-m4-airlift.md b/content/microcontrollers/metro-m4-airlift.md
deleted file mode 100644
index e4de66fc..00000000
--- a/content/microcontrollers/metro-m4-airlift.md
+++ /dev/null
@@ -1,56 +0,0 @@
----
-title: "Adafruit Metro M4 Express AirLift"
-weight: 3
----
-
-The [Adafruit Metro M4 Express AirLift](https://www.adafruit.com/product/4000) is an ARM development board based on the Atmel [ATSAMD51J19](https://www.microchip.com/wwwproducts/en/ATSAMD51J19) family of SoC that has Arduino shield compatible form factor, and a built-in EspressIf ESP32 Wi-Fi Co processor.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Adafruit Metro M4 Airlift](../machine/metro-m4-airlift)
-
-## Flashing
-
-### UF2
-
-The Metro M4 Express comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
-
-### CLI Flashing
-
-- Plug your Metro M4 Express into your computer's USB port.
-- Flash your TinyGo program to the board using this command:
-
-    ```shell
-    tinygo flash -target=metro-m4-airlift [PATH TO YOUR PROGRAM]
-    ```
-
-- The Metro M4 Express board should restart and then begin running your program.
-
-### Troubleshooting
-
-If you have troubles getting your Metro M4 Express board to receive code, try this:
-
-- Press the "RESET" button on the board two times to get the Metro M4 Express board ready to receive code.
-- The Metro M4 Express board will appear to your computer like a USB drive.
-- Now try running the command as above:
-
-    ```shell
-    tinygo flash -target=metro-m4-airlift [PATH TO YOUR PROGRAM]
-    ```
-
-Once you have updated your Metro M4 Express board the first time, after that you should be able to flash it entirely from the command line.
-
-## Notes
-
-You can use the USB port to the Metro M4 Express as a serial port. `UART0` refers to this connection.
diff --git a/content/microcontrollers/nrf52840-mdk.md b/content/microcontrollers/nrf52840-mdk.md
deleted file mode 100644
index d01dd16b..00000000
--- a/content/microcontrollers/nrf52840-mdk.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "nRF52840-MDK"
-weight: 3
----
-
-The [nRF52840-MDK](https://wiki.makerdiary.com/nrf52840-mdk/) is an open-source, micro development kit for IoT applications based on the Nordic Semiconductor [nRF52840](https://www.nordicsemi.com/eng/Products/nRF52840) SoC chip.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | Not yet |
-| PWM      | YES | Not yet |
-| Bluetooth      | YES | YES |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the nRF52840-MDK](../machine/nrf52840-mdk)
-
-## Flashing
-
-### OpenOCD
-
-Programs are loaded onto the nRF52840-MDK board using the `openocd` command line utility program. You must install [OpenOCD](http://openocd.org/) before you will be able to flash the nRF52840-MDK board with your TinyGo code.
-
-- Plug your nRF52840-MDK into your computer's USB port.
-- Build and flash your TinyGo program using `tinygo flash -target=nrf52840-mdk`
-
-## Notes
-
-Bluetooth support is now available for nRF52840 boards. See https://github.com/tinygo-org/bluetooth for more information.
diff --git a/content/microcontrollers/particle-argon.md b/content/microcontrollers/particle-argon.md
deleted file mode 100644
index 00144cfb..00000000
--- a/content/microcontrollers/particle-argon.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: "Particle Argon"
-weight: 3
----
-
-[The Particle Argon](https://docs.particle.io/datasheets/wi-fi/argon-datasheet/) is a powerful Wi-Fi enabled development board. It is based on the Nordic [nRF52840](https://www.nordicsemi.com/eng/Products/nRF52840) and ESP32 2.4 GHz Wi-Fi coprocessor.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
-| Bluetooth      | YES | Not yet |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Particle Argon](../machine/particle-argon)
-
-## Flashing
-
-### OpenOCD
-
-Programs are loaded onto the Particle Argon board using the `openocd` command line utility program. You must install [OpenOCD](http://openocd.org/) before you will be able to flash the Particle Argon board with your TinyGo code.
-
-- Plug your [Particle Debugger](https://store.particle.io/collections/accessories/products/particle-debugger) to Argon's debugging connector
-- Build and flash your TinyGo program using `tinygo flash -target=particle-argon`
-
-## Notes
-
-You can use the USB port to the Particle Argon as a serial port. `UART0` refers to this connection.
-
-Bluetooth support is in development but not yet completed.
diff --git a/content/microcontrollers/particle-boron.md b/content/microcontrollers/particle-boron.md
deleted file mode 100644
index a5c31470..00000000
--- a/content/microcontrollers/particle-boron.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: "Particle Boron"
-weight: 3
----
-
-[The Particle Boron](https://docs.particle.io/datasheets/cellular/boron-datasheet/) The Boron is a powerful LTE CAT-M1/2G/3G enabled development kit that supports cellular networks and Bluetooth LE (BLE). It is based on the Nordic [nRF52840](https://www.nordicsemi.com/eng/Products/nRF52840) and u-blox SARA coprocessor.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
-| Bluetooth      | YES | Not yet |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Particle Boron](../machine/particle-boron)
-
-## Flashing
-
-### OpenOCD
-
-Programs are loaded onto the Particle Boron board using the `openocd` command line utility program. You must install [OpenOCD](http://openocd.org/) before you will be able to flash the Particle Boron board with your TinyGo code.
-
-- Plug your [Particle Debugger](https://store.particle.io/collections/accessories/products/particle-debugger) to Boron's debugging connector
-- Build and flash your TinyGo program using `tinygo flash -target=particle-boron`
-
-## Notes
-
-You can use the USB port to the Particle Boron as a serial port. `UART0` refers to this connection.
-
-Bluetooth support is in development but not yet completed.
diff --git a/content/microcontrollers/particle-xenon.md b/content/microcontrollers/particle-xenon.md
deleted file mode 100644
index d00a6199..00000000
--- a/content/microcontrollers/particle-xenon.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: "Particle Xenon"
-weight: 3
----
-
-[The Particle Xenon](https://docs.particle.io/datasheets/discontinued/xenon-datasheet/) is a low cost mesh-enabled development board.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
-| Bluetooth      | YES | Not yet |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Particle Xenon](../machine/particle-xenon)
-
-## Flashing
-
-### OpenOCD
-
-Programs are loaded onto the Particle Xenon board using the `openocd` command line utility program. You must install [OpenOCD](http://openocd.org/) before you will be able to flash the Particle Xenon board with your TinyGo code.
-
-- Plug your [Particle Debugger](https://store.particle.io/collections/accessories/products/particle-debugger) to Xenon's debugging connector
-- Build and flash your TinyGo program using `tinygo flash -target=particle-xenon`
-
-## Notes
-
-You can use the USB port to the Particle Xenon as a serial port. `UART0` refers to this connection.
-
-Bluetooth support is in development but not yet completed.
diff --git a/content/microcontrollers/pca10031.md b/content/microcontrollers/pca10031.md
deleted file mode 100644
index 16ed796d..00000000
--- a/content/microcontrollers/pca10031.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: "PCA10031"
-weight: 3
----
-
-The [Nordic Semiconductor PCA10031](https://www.nordicsemi.com/eng/Products/nRF51-Dongle) is a low-cost, versatile USB development dongle for wireless applications based on the Nordic Semiconductor [nRF51422](https://www.nordicsemi.com/eng/Products/ANT/nRF51422) chip using the nRF51 series SoC.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | Not yet |
-| I2C      | YES | Not yet |
-| ADC      | YES | Not yet |
-| PWM      | YES | Not yet |
-| Bluetooth      | YES | YES |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the PCA10031](../machine/pca10031)
-
-## Flashing
-
-### nrfjprog/J-Link
-
-Programs are loaded onto the pca10031 board using the `nrfjprog` command line utility program.
-
-First install the J-Link Software and Documentation Pack from Segger: [https://www.segger.com/downloads/jlink/#J-LinkSoftwareAndDocumentationPack](https://www.segger.com/downloads/jlink/#J-LinkSoftwareAndDocumentationPack)
-
-Then install the nRF5x Command-Line Tools: [https://docs.zephyrproject.org/latest/guides/tools/nordic_segger.html#nrf5x-command-line-tools-installation](https://docs.zephyrproject.org/latest/guides/tools/nordic_segger.html#nrf5x-command-line-tools-installation)
-
-Once you have installed both of these correctly, you will be able to flash the pca10031 board with your TinyGo code.
-
-- Plug your pca10031 into your computer's USB port.
-- Build and flash your TinyGo program using `tinygo flash -target=pca10031`
diff --git a/content/microcontrollers/pca10040.md b/content/microcontrollers/pca10040.md
deleted file mode 100644
index 1ea7141a..00000000
--- a/content/microcontrollers/pca10040.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: "PCA10040"
-weight: 3
----
-
-The [Nordic Semiconductor PCA10040](https://www.nordicsemi.com/eng/Products/Bluetooth-low-energy/nRF52-DK) is a single-board development kit for wireless applications based on the Nordic Semiconductor [nRF52832](https://www.nordicsemi.com/eng/Products/Bluetooth-low-energy/nRF52832) SoC.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
-| Bluetooth      | YES | YES |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the PCA10040](../machine/pca10040)
-
-## Flashing
-
-### nrfjprog/J-Link
-
-Programs are loaded onto the pca10040 board using the `nrfjprog` command line utility program.
-
-First install the J-Link Software and Documentation Pack from Segger: [https://www.segger.com/downloads/jlink/#J-LinkSoftwareAndDocumentationPack](https://www.segger.com/downloads/jlink/#J-LinkSoftwareAndDocumentationPack)
-
-Then install the nRF5x Command-Line Tools: [https://docs.zephyrproject.org/latest/guides/tools/nordic_segger.html#nrf5x-command-line-tools-installation](https://docs.zephyrproject.org/latest/guides/tools/nordic_segger.html#nrf5x-command-line-tools-installation)
-
-Once you have installed both of these correctly, you will be able to flash the pca10040 board with your TinyGo code.
-
-- Plug your pca10040 into your computer's USB port.
-- Build and flash your TinyGo program using `tinygo flash -target=pca10040`
diff --git a/content/microcontrollers/pca10056.md b/content/microcontrollers/pca10056.md
deleted file mode 100644
index 195cb00f..00000000
--- a/content/microcontrollers/pca10056.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: "PCA10056"
-weight: 3
----
-
-The [Nordic Semiconductor PCA10056](https://www.nordicsemi.com/Software-and-Tools/Development-Kits/nRF52840-DK) is a single-board development kit for wireless applications based on the Nordic Semiconductor [nRF52840](https://www.nordicsemi.com/eng/Products/nRF52840) SoC.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | Not yet |
-| PWM      | YES | Not yet |
-| Bluetooth      | YES | YES |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the PCA10056](../machine/pca10056)
-
-## Flashing
-
-### nrfjprog/J-Link
-
-Programs are loaded onto the pca10056 board using the `nrfjprog` command line utility program.
-
-First install the J-Link Software and Documentation Pack from Segger: [https://www.segger.com/downloads/jlink/#J-LinkSoftwareAndDocumentationPack](https://www.segger.com/downloads/jlink/#J-LinkSoftwareAndDocumentationPack)
-
-Then install the nRF5x Command-Line Tools: [https://docs.zephyrproject.org/latest/guides/tools/nordic_segger.html#nrf5x-command-line-tools-installation](https://docs.zephyrproject.org/latest/guides/tools/nordic_segger.html#nrf5x-command-line-tools-installation)
-
-Once you have installed both of these correctly, you will be able to flash the pca10056 board with your TinyGo code.
-
-- Plug your pca10056 into your computer's USB port.
-- Build and flash your TinyGo program using `tinygo flash -target=pca10056`
diff --git a/content/microcontrollers/pybadge.md b/content/microcontrollers/pybadge.md
deleted file mode 100644
index 19a6d774..00000000
--- a/content/microcontrollers/pybadge.md
+++ /dev/null
@@ -1,59 +0,0 @@
----
-title: "Adafruit PyBadge"
-weight: 3
----
-
-The [Adafruit PyBadge](https://www.adafruit.com/product/4200) is a ARM development board based on the Atmel [ATSAMD51J19A](https://www.microchip.com/wwwproducts/en/ATSAMD51J19A) family of SoC.
-
-It has many built-in devices, such as a 1.8" 160x128 Color TFT Display, 8 x buttons, 5 x NeoPixels, a triple-axis accelerometer, a light sensor, and a speaker. The PyBadge uses the ST7735 display, so you may use the tinygo-org st7735 driver. The accelerometer is the LIS3DH so you may use the tinygo lis3dh driver
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Adafruit PyBadge](../machine/pybadge)
-
-## Flashing
-
-### UF2
-
-The PyBadge comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
-
-### CLI Flashing
-
-- Plug your PyBadge into your computer's USB port.
-- Flash your TinyGo program to the board using this command:
-
-    ```shell
-    tinygo flash -target=pybadge [PATH TO YOUR PROGRAM]
-    ```
-
-- The PyBadge board should restart and then begin running your program.
-
-### Troubleshooting
-
-If you have troubles getting your PyBadge board to receive code, try this:
-
-- Press the "RESET" button on the board two times to get the PyBadge board ready to receive code.
-- The PyBadge board will appear to your computer like a USB drive.
-- Now try running the command as above:
-
-
-```shell
-tinygo flash -target=pybadge [PATH TO YOUR PROGRAM]
-```
-
-Once you have updated your PyBadge board the first time, after that you should be able to flash it entirely from the command line.
-
-## Notes
-
-You can use the USB port to the PyBadge as a serial port. `UART0` refers to this connection.
diff --git a/content/microcontrollers/pygamer.md b/content/microcontrollers/pygamer.md
deleted file mode 100644
index 8352d485..00000000
--- a/content/microcontrollers/pygamer.md
+++ /dev/null
@@ -1,59 +0,0 @@
----
-title: "Adafruit PyGamer"
-weight: 3
----
-
-The [Adafruit PyGamer](https://www.adafruit.com/product/4242) is a ARM development board based on the Atmel [ATSAMD51J19A](https://www.microchip.com/wwwproducts/en/ATSAMD51J19A) family of SoC.
-
-It has many built-in devices, such as a 1.8" 160x128 Color TFT Display, a dual-potentiometer analog stick, 4 x square-top buttons, 5 x NeoPixel LED, a triple-axis accelerometer, a light sensor, and a speaker.  The PyGamer uses the ST7735 display, so you may use the tinygo-org st7735 driver. The accelerometer is the LIS3DH so you may use the tinygo lis3dh driver.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Adafruit PyGamer](../machine/pygamer)
-
-## Flashing
-
-### UF2
-
-The PyGamer comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
-
-### CLI Flashing
-
-- Plug your PyGamer into your computer's USB port.
-- Flash your TinyGo program to the board using this command:
-
-    ```shell
-    tinygo flash -target=pygamer [PATH TO YOUR PROGRAM]
-    ```
-
-- The PyGamer board should restart and then begin running your program.
-
-### Troubleshooting
-
-If you have troubles getting your PyGamer board to receive code, try this:
-
-- Press the "RESET" button on the board two times to get the PyGamer board ready to receive code.
-- The PyGamer board will appear to your computer like a USB drive.
-- Now try running the command as above:
-
-
-```shell
-tinygo flash -target=pygamer [PATH TO YOUR PROGRAM]
-```
-
-Once you have updated your PyGamer board the first time, after that you should be able to flash it entirely from the command line.
-
-## Notes
-
-You can use the USB port to the PyGamer as a serial port. `UART0` refers to this connection.
diff --git a/content/microcontrollers/pyportal.md b/content/microcontrollers/pyportal.md
deleted file mode 100644
index c2838d95..00000000
--- a/content/microcontrollers/pyportal.md
+++ /dev/null
@@ -1,59 +0,0 @@
----
-title: "Adafruit PyPortal"
-weight: 3
----
-
-The [Adafruit PyPortal](https://www.adafruit.com/product/4116) is a ARM board based on the Microchip [ATSAMD51J20A](https://www.microchip.com/wwwproducts/en/ATSAMD51J20A) family of SoC.
-
-The PyPortal also has an Espressif ESP32 Wi-Fi coprocessor with TLS/SSL support built-in. PyPortal has a 3.2″ 320 x 240 color TFT with resistive touch screen. PyPortal includes: speaker, light sensor, temperature sensor, NeoPixel, microSD card slot, 8MB flash, plug-in ports for I2C and 2 analog/digital pins,
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Adafruit PyPortal](../machine/pyportal)
-
-## Flashing
-
-### UF2
-
-The PyPortal comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
-
-### CLI Flashing
-
-- Plug your PyPortal into your computer's USB port.
-- Flash your TinyGo program to the board using this command:
-
-    ```shell
-    tinygo flash -target=pyportal [PATH TO YOUR PROGRAM]
-    ```
-
-- The PyPortal board should restart and then begin running your program.
-
-### Troubleshooting
-
-If you have troubles getting your PyPortal board to receive code, try this:
-
-- Press the "RESET" button on the board two times to get the PyPortal board ready to receive code.
-- The PyPortal board will appear to your computer like a USB drive.
-- Now try running the command as above:
-
-
-```shell
-tinygo flash -target=pyportal [PATH TO YOUR PROGRAM]
-```
-
-Once you have updated your PyPortal board the first time, after that you should be able to flash it entirely from the command line.
-
-## Notes
-
-You can use the USB port to the PyPortal as a serial port. `UART0` refers to this connection.
diff --git a/content/microcontrollers/qtpy.md b/content/microcontrollers/qtpy.md
deleted file mode 100644
index 5a83aeba..00000000
--- a/content/microcontrollers/qtpy.md
+++ /dev/null
@@ -1,56 +0,0 @@
----
-title: "Adafruit QtPy"
-weight: 3
----
-
-The [Adafruit QtPy](https://www.adafruit.com/product/4600) is a tiny ARM development board based on the Atmel [ATSAMD21E18](https://www.microchip.com/wwwproducts/en/ATSAMD21E18) family of SoC.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Adafruit QtPy](../machine/qtpy)
-
-## Flashing
-
-### UF2
-
-The QtPy comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
-
-### CLI Flashing
-
-- Plug your QtPy into your computer's USB port.
-- Flash your TinyGo program to the board using this command:
-
-    ```shell
-    tinygo flash -target=qtpy [PATH TO YOUR PROGRAM]
-    ```
-
-- The QtPy board should restart and then begin running your program.
-
-### Troubleshooting
-
-If you have troubles getting your QtPy board to receive code, try this:
-
-- Press the "RESET" button on the board two times to get the QtPy board ready to receive code.
-- The QtPy board will appear to your computer like a USB drive.
-- Now try running the `tinygo flash` command as above:
-
-    ```shell
-    tinygo flash -target=qtpy [PATH TO YOUR PROGRAM]
-    ```
-
-Once you have updated your QtPy board the first time, after that you should be able to flash it entirely from the command line.
-
-## Notes
-
-You can use the USB port to the QtPy as a serial port. `UART0` refers to this connection.
diff --git a/content/microcontrollers/stm32f4discovery.md b/content/microcontrollers/stm32f4discovery.md
deleted file mode 100644
index d6f4223b..00000000
--- a/content/microcontrollers/stm32f4discovery.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: "STM32F4 Discovery"
-weight: 3
----
-
-The [STM32F4 Discovery](https://www.st.com/en/evaluation-tools/stm32f4discovery.html) is an ARM development board based on the ST Micro [STM32F407](https://www.st.com/resource/en/datasheet/stm32f407vg.pdf) SoC.
-
-It has an onboard LIS302DL or LIS3DSH accelerometer, MP45DT02 MEMS digital microphone, an
-CS43L22 audio DAC, 2 user buttons, and 4 user LEDs.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | Not yet |
-| ADC      | YES | Not yet |
-| PWM      | YES | Not yet |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the STM32F4 Discovery](../machine/stm32f4disco)
-
-## Flashing
-
-### OpenOCD
-
-Programs are loaded onto the STM32F4 Discovery with the onboard [STLink v2](https://www.st.com/en/development-tools/st-link-v2.html) hardware programmer, using the `openocd` command line utility program to perform the board flashing. You must install [OpenOCD](http://openocd.org/) before you will be able to flash the STM32F4 Discovery board with your TinyGo code.
-
-- Plug your STM32F4 Discovery into your computer's USB port.
-- Build and flash your TinyGo program using `tinygo flash -target=stm32f4disco`
diff --git a/content/microcontrollers/teensy36.md b/content/microcontrollers/teensy36.md
deleted file mode 100644
index 77853882..00000000
--- a/content/microcontrollers/teensy36.md
+++ /dev/null
@@ -1,56 +0,0 @@
----
-title: "Teensy 3.6"
-weight: 3
----
-
-The [PJRC Teensy 3.6](https://www.pjrc.com/store/teensy36.html) is a small ARM development board based on the NXP [MK66FX1M0VMD18](https://www.nxp.com/docs/en/data-sheet/K66P144M180SF5V2.pdf) 32-bit 180 MHz ARM Cortex-M4.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | Not yet |
-| I2C      | YES | Not yet |
-| ADC      | YES | Not yet |
-| PWM      | YES | Not Yet |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Teensy 3.6](../machine/teensy36)
-
-## Flashing
-
-### teensy_loader_cli
-
-In order to flash your TinyGo programs onto the Teensy 3.6 board, you will need to install the `teensy_loader_cli` (https://github.com/PaulStoffregen/teensy_loader_cli) on your machine.
-
-### CLI Flashing
-
-- Plug your Teensy 3.6 into your computer's USB port.
-- Flash your TinyGo program to the board using this command:
-
-    ```shell
-    tinygo flash -target=teensy36 [PATH TO YOUR PROGRAM]
-    ```
-
-- The Teensy 3.6 board should restart and then begin running your program.
-
-### Troubleshooting
-
-If you have troubles getting your Teensy 3.6 board to receive code, try this:
-
-- Press the "RESET" button on the board two times to get the Teensy 3.6 board ready to receive code.
-- The Teensy 3.6 board will appear to your computer like a USB drive.
-- Now try running the command as above:
-
-    ```shell
-    tinygo flash -target=teensy36 [PATH TO YOUR PROGRAM]
-    ```
-
-Once you have updated your Teensy 3.6 board the first time, after that you should be able to flash it entirely from the command line.
-
-## Notes
-
-You cannot yet use the USB port to the Teensy 3.6 as a USB CDC serial port.
diff --git a/content/microcontrollers/teensy40.md b/content/microcontrollers/teensy40.md
deleted file mode 100644
index 434cd42b..00000000
--- a/content/microcontrollers/teensy40.md
+++ /dev/null
@@ -1,56 +0,0 @@
----
-title: "Teensy 4.0"
-weight: 3
----
-
-The [PJRC Teensy 4.0](https://www.pjrc.com/store/teensy40.html) is a small ARM development board based on the NXP [iMXRT1062](https://www.nxp.com/docs/en/nxp/data-sheets/IMXRT1060CEC.pdf) 32-bit 600 MHz ARM Cortex-M7.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | Not yet |
-| I2C      | YES | Not yet |
-| ADC      | YES | Not yet |
-| PWM      | YES | Not Yet |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Teensy 4.0](../machine/teensy40)
-
-## Flashing
-
-### teensy_loader_cli
-
-In order to flash your TinyGo programs onto the Teensy 4.0 board, you will need to install the `teensy_loader_cli` (https://github.com/PaulStoffregen/teensy_loader_cli) on your machine.
-
-### CLI Flashing
-
-- Plug your Teensy 4.0 into your computer's USB port.
-- Flash your TinyGo program to the board using this command:
-
-    ```shell
-    tinygo flash -target=teensy36 [PATH TO YOUR PROGRAM]
-    ```
-
-- The Teensy 4.0 board should restart and then begin running your program.
-
-### Troubleshooting
-
-If you have troubles getting your Teensy 4.0 board to receive code, try this:
-
-- Press the "RESET" button on the board two times to get the Teensy 4.0 board ready to receive code.
-- The Teensy 4.0 board will appear to your computer like a USB drive.
-- Now try running the command as above:
-
-    ```shell
-    tinygo flash -target=teensy40 [PATH TO YOUR PROGRAM]
-    ```
-
-Once you have updated your Teensy 4.0 board the first time, after that you should be able to flash it entirely from the command line.
-
-## Notes
-
-You cannot yet use the USB port to the Teensy 4.0 as a USB CDC serial port.
diff --git a/content/microcontrollers/wioterminal.md b/content/microcontrollers/wioterminal.md
deleted file mode 100644
index 02099b82..00000000
--- a/content/microcontrollers/wioterminal.md
+++ /dev/null
@@ -1,57 +0,0 @@
----
-title: "Seeed Wio Terminal"
-weight: 3
----
-
-The [Seeed Wio Terminal](https://www.seeedstudio.com/Wio-Terminal-p-4509.html) is a tiny ARM development board based on the Atmel [ATSAMD51P20](https://www.microchip.com/wwwproducts/en/ATSAMD51P20A) family of SoC.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Seeed Wio Terminal](../machine/wioterminal)
-
-## Flashing
-
-### UF2
-
-The Wio Terminal comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
-
-### CLI Flashing
-
-- Plug your Wio Terminal into your computer's USB port.
-- Flash your TinyGo program to the board using this command:
-
-    ```shell
-    tinygo flash -target=wioterminal [PATH TO YOUR PROGRAM]
-    ```
-
-- The Wio Terminal board should restart and then begin running your program.
-
-### Troubleshooting
-
-If you have troubles getting your Wio Terminal board to receive code, try this:
-
-- [Slide the "RESET" switch on the board two times](https://wiki.seeedstudio.com/Wio-Terminal-Getting-Started/#faq) to get the Wio Terminal board ready to receive code.
-- The Wio Terminal board will appear to your computer like a USB drive.
-- Now try running the command as above:
-
-
-```shell
-tinygo flash -target=wioterminal [PATH TO YOUR PROGRAM]
-```
-
-Once you have updated your Wio Terminal board the first time, after that you should be able to flash it entirely from the command line.
-
-## Notes
-
-You can use the USB port to the Wio Terminal as a serial port. `UART0` refers to this connection.
diff --git a/content/microcontrollers/x9-pro.md b/content/microcontrollers/x9-pro.md
deleted file mode 100644
index 9ede1c22..00000000
--- a/content/microcontrollers/x9-pro.md
+++ /dev/null
@@ -1,25 +0,0 @@
----
-title: "X9 Pro Smartwatch"
-weight: 3
----
-
-Info here
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | ? | ? |
-| UART      | ? | ? |
-| SPI      | ? | ? |
-| I2C      | ? | ? |
-| ADC      | ? | ? |
-| PWM      | ? | ? |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the X9 Pro](../machine/x9pro)
-
-## Flashing
-
-How to do it...
diff --git a/content/microcontrollers/xiao.md b/content/microcontrollers/xiao.md
deleted file mode 100644
index beadfb04..00000000
--- a/content/microcontrollers/xiao.md
+++ /dev/null
@@ -1,58 +0,0 @@
----
-title: "Seeed Seeeduino XIAO"
-weight: 3
----
-
-The [Seeed Seeeduino XIAO](https://www.seeedstudio.com/Seeeduino-XIAO-Arduino-Microcontroller-SAMD21-Cortex-M0+-p-4426.html) is a tiny ARM development board based on the Atmel [ATSAMD21G18](https://www.microchip.com/wwwproducts/en/ATSAMD21G18) family of SoC.
-
-## Interfaces
-
-| Interface | Hardware Supported | TinyGo Support |
-| --------- | ------------- | ----- |
-| GPIO      | YES | YES |
-| UART      | YES | YES |
-| SPI      | YES | YES |
-| I2C      | YES | YES |
-| ADC      | YES | YES |
-| PWM      | YES | YES |
-
-## Machine Package Docs
-
-[Documentation for the machine package for the Seeed Seeeduino XIAO](../machine/xiao)
-
-## Flashing
-
-### UF2
-
-The XIAO comes with the [UF2 bootloader](https://github.com/Microsoft/uf2) already installed.
-
-### CLI Flashing
-
-- Plug your XIAO into your computer's USB port.
-- Flash your TinyGo program to the board using this command:
-
-    ```shell
-    tinygo flash -target=xiao [PATH TO YOUR PROGRAM]
-    ```
-
-- The XIAO board should restart and then begin running your program.
-
-### Troubleshooting
-
-If you have troubles getting your XIAO board to receive code, try this:
-
-- [Short the "RST pins" two times](https://wiki.seeedstudio.com/Seeeduino-XIAO/#reset) to get the XIAO board ready to receive code.
-- The XIAO board will appear to your computer like a USB drive.
-- Now try running the command as above:
-
-
-```shell
-tinygo flash -target=xiao [PATH TO YOUR PROGRAM]
-```
-
-Once you have updated your XIAO board the first time, after that you should be able to flash it entirely from the command line.
-
-## Notes
-
-You can use the USB port to the XIAO as a serial port. `UART0` refers to this connection.
-
diff --git a/content/play/_index.md b/content/play/_index.md
new file mode 100644
index 00000000..c055ab16
--- /dev/null
+++ b/content/play/_index.md
@@ -0,0 +1,156 @@
+---
+title: Playground
+description: "TinyGo playground. Run Go code directly in the browser and simulate some popular development boards."
+---
+
+<link rel="stylesheet" href="/playground/simulator.css">
+<link rel="stylesheet" href="/playground/simulator-bootstrap.css">
+<script type="module" src="/playground-play.js"></script>
+<style>
+#playground {
+	margin-top: 1.5rem;
+	margin-bottom: 0.75rem;
+	display: flex;
+	flex-direction: column;
+}
+#playground-header {
+	display: flex;
+	align-items: center;
+	justify-content: space-between;
+	flex-wrap: wrap;
+}
+#target .project-name .buttons {
+	margin-left: 16px;
+}
+.playground-editor {
+	min-height: 60vh;
+	flex: 1 0 0;
+	resize: none;
+}
+.playground-editor:not([style*="height"]) {
+	max-height: initial;
+}
+.playground-editor .cm-scroller {
+	flex: 1 0 0;
+}
+#middle {
+	display: flex;
+	flex-grow: 1;
+	flex-direction: column;
+	gap: 0.75rem;
+}
+#output {
+	flex: 1 0 0;
+}
+@media (min-width: 768px) {
+	#playground {
+		margin-top: 5rem;
+		/* 100% - header - padding bottom */
+		height: calc(100vh - 5rem - 0.75rem);
+	}
+	#middle {
+		flex-direction: row;
+	}
+	.playground-editor {
+		min-height: initial;
+	}
+}
+</style>
+<div id="playground">
+	<div id="playground-header">
+		<h2>Playground</h2>
+		<div>
+			<div id="target" class="btn-group mb-2">
+				<button type="button" class="btn btn-primary dropdown-toggle" data-bs-toggle="dropdown" aria-haspopup="true" aria-expanded="false">
+				Console (TinyGo)
+				</button>
+				<div class="dropdown-menu">
+					<a class="dropdown-item active" href>Console (TinyGo)</a>
+					<span id="target-loading" class="dropdown-item disabled">Loading...</span>
+				</div>
+			</div>
+			<button type="button" id="btn-flash" class="btn btn-secondary mb-2" disabled>Flash</button>
+			<button type="button" id="btn-share" class="btn btn-secondary mb-2">Share</button>
+			<button type="button" id="btn-about" class="btn btn-secondary mb-2" data-bs-toggle="modal" data-bs-target="#aboutModal">About</button>
+			<a href="/tour/" class="btn btn-secondary mb-2">Tour</a>
+		</div>
+	</div>
+	<div id="middle">
+		<div class="playground-editor" tabindex="-1"></div>
+		<div id="output" class="simulator inline">{{< readfile "/simulator/simulator.md" >}}</div>
+	</div>
+	<div class="modal fade" id="aboutModal" tabindex="-1" aria-labelledby="aboutModalTitle" aria-hidden="true">
+		<div class="modal-dialog">
+			<div class="modal-content">
+				<div class="modal-header">
+					<h1 class="modal-title fs-5" id="exampleModalLabel">About TinyGo Playground</h1>
+					<button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+				</div>
+				<div class="modal-body">
+					<p>
+						The TinyGo Playground is a service provided by the TinyGo project
+						to compile and run small code samples directly in the browser. It
+						has been heavily inspired by the <a
+						href="https://play.golang.org/">Go Playground</a> but differs in
+						some significant ways:
+					</p>
+					<ul>
+						<li>
+							We use the <a href="https://github.com/tinygo-org/tinygo">TinyGo compiler</a> in addition to the main Go compiler.
+						</li>
+						<li>
+							Instead of running code on the server, code is compiled to <a
+							href="https://webassembly.org/">WebAssembly</a> and runs
+							directly in the browser.
+						</li>
+						<li>
+							It can simulate a few popular boards directly in the browser.
+							However, please note that this is a simulation which can differ
+							in behavior from how the program will run on an actual device.
+						</li>
+						<li>
+							Boards that support drag-and-drop programming can be flashed
+							directly using the Flash button.
+						</li>
+					</ul>
+					<p>
+						Like the Go Playground, it's possible to share code
+						snippets. These code snippets are stored on Google's
+						servers in the US and can be viewed by some TinyGo
+						members. While we'll try to make sure the shared data
+						can only be accessed by those who have the URL, we
+						cannot guarantee security. If you accidentally shared
+						something that should not be shared (for example, a
+						password or personally identifying information), you can
+						contact us at
+						<a href="mailto:privacy@tinygo.org">privacy@tinygo.org</a>
+						with the URL so we can remove it.
+					</p>
+					<p>
+						Source code of the playground: <a
+						href="https://github.com/tinygo-org/playground">github.com/tinygo-org/playground</a>.
+					</p>
+				</div>
+				<div class="modal-footer">
+					<button type="button" class="btn btn-primary" data-bs-dismiss="modal">Close</button>
+				</div>
+			</div>
+		</div>
+	</div>
+	<div class="modal modal-lg fade" id="shareModal" tabindex="-1" aria-labelledby="shareModalLabel" aria-hidden="true">
+		<div class="modal-dialog">
+			<div class="modal-content">
+				<div class="modal-header">
+					<h1 class="modal-title fs-5" id="shareModalLabel">Share</h1>
+					<button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+				</div>
+				<div class="modal-body">
+					<div class="input-group">
+						<input type="text" class="form-control user-select-all" placeholder="Loading..." readonly/>
+						<button class="btn btn-outline-secondary copy-to-clipboard" type="button" data-bs-toggle="tooltip" data-bs-title="Copy to clipboard" data-bs-placement="bottom" disabled><span class="fa fa-clipboard"></span></button>
+					</div>
+				</div>
+			</div>
+		</div>
+	</div>
+</div>
diff --git a/content/search.md b/content/search.md
new file mode 100644
index 00000000..394feea5
--- /dev/null
+++ b/content/search.md
@@ -0,0 +1,4 @@
+---
+title: Search Results
+layout: search
+---
diff --git a/content/simulator/simulator.md b/content/simulator/simulator.md
new file mode 100644
index 00000000..d75e3bf8
--- /dev/null
+++ b/content/simulator/simulator.md
@@ -0,0 +1,51 @@
+<div class="schematic-buttons">
+	<button class="schematic-button-pause schematic-button" title="Pause/resume the simulation">
+		<!-- only one of these two images is visible at a time -->
+		<img src="/playground/resources/codicon/debug-pause.svg" class="button-img-pause"/>
+		<img src="/playground/resources/codicon/play.svg" class="button-img-play"/>
+	</button>
+</div>
+<svg class="schematic" tabindex="0">
+	<g class="schematic-wrapper" style="transform: translate(50%, 50%)">
+		<g class="schematic-parts"></g>
+		<g class="schematic-wires"></g>
+	</g>
+</svg>
+<div class="card-header">
+	<ul class="nav nav-tabs card-header-tabs" role="tablist">
+		<li class="nav-item" role="presentation">
+			<button class="nav-link active panel-tab-terminal" id="simulator-tab-terminal" data-bs-toggle="tab" data-bs-target="#simulator-panel-terminal" type="button" role="tab" aria-controls="simulator-panel-terminal" aria-selected="true">Terminal</button>
+		</li>
+		<li class="nav-item" role="presentation">
+			<button class="nav-link" id="simulator-properties-tab" data-bs-toggle="tab" data-bs-target="#simulator-panel-properties" type="button" role="tab" aria-controls="simulator-panel-properties" aria-selected="false">Properties</button>
+		</li>
+		<li class="nav-item" role="presentation">
+			<button class="nav-link" id="simulator-power-tab" data-bs-toggle="tab" data-bs-target="#simulator-panel-power" type="button" role="tab" aria-controls="simulator-panel-power" aria-selected="false">Power</button>
+		</li>
+		<li class="nav-item" role="presentation">
+			<button class="nav-link" id="simulator-add-tab" data-bs-toggle="tab" data-bs-target="#simulator-panel-add" type="button" role="tab" aria-controls="simulator-panel-add" aria-selected="false">Add</button>
+		</li>
+	</ul>
+</div>
+<div class="tab-content">
+	<div class="tab-pane active terminal-box" id="simulator-panel-terminal" role="tabpanel" aria-labelledby="simulator-tab-terminal">
+		<div class="terminal" tabindex="0"></div>
+	</div>
+	<div class="tab-pane panel-properties content" id="simulator-panel-properties" role="tabpanel" aria-labelledby="simulator-properties-tab">
+		<div class="content" tabindex="0"></div>
+	</div>
+	<div class="tab-pane panel-power content" id="simulator-panel-power" role="tabpanel" aria-labelledby="simulator-power-tab">
+		<div class="content" tabindex="0">
+			<div class="power-table">Loading...</div>
+			<p class="mb-0 mt-3"><strong>Note:</strong> these numbers are estimates, based on datasheets and measurements. They don't include everything and may be wrong.</p>
+		</div>
+	</div>
+	<div class="tab-pane panel-add" id="simulator-panel-add" role="tabpanel" aria-labelledby="simulator-add-tab">
+			<div class="content" tabindex="0">Loading...</div>
+	</div>
+</div>
+<div class="schematic-tooltip"></div>
+<div class="templates d-none">
+	<button class="panel-add-button btn btn-primary btn-sm">Add</button>
+	<select class="panel-add-select form-select form-select-sm"></select>
+</div>
diff --git a/content/tour/_index.md b/content/tour/_index.md
new file mode 100644
index 00000000..3469d3da
--- /dev/null
+++ b/content/tour/_index.md
@@ -0,0 +1,16 @@
+---
+title: "Tour of TinyGo"
+type: "docs"
+
+cascade:
+  github_repo: https://github.com/tinygo-org/tinygo-site
+  github_subdir: content/tour
+  path_base_for_github_subdir: content/tour
+  github_branch: dev
+---
+
+Welcome to the tour of TinyGo!
+
+This tour assumes you're already familiar with Go. If not, you can go through the [tour of Go](https://go.dev/tour/) to get started.
+
+Every example in this tour is runnable directly in the browser, and most can be downloaded directly to your own electronics board (like the [Adafruit Circuit Playground Express](https://www.adafruit.com/product/3333)).
diff --git a/content/tour/blink/_index.md b/content/tour/blink/_index.md
new file mode 100644
index 00000000..1347d96a
--- /dev/null
+++ b/content/tour/blink/_index.md
@@ -0,0 +1,10 @@
+---
+title: "Blinking LED"
+type: "docs"
+description: "Write the \"hello world\" of electronics by making an LED blink!"
+weight: 1
+---
+
+This short tour will get you up to speed with blinking a simple LED. This is a great way to start, especially if you've never done electronics before: if the LED blinks you know that everything works to continue in the tour. If you can't get it to work, you might need to do some troubleshooting before you can continue.
+
+This tour also teaches the basics of the TinyGo-specific machine package.
diff --git a/content/tour/blink/external.md b/content/tour/blink/external.md
new file mode 100644
index 00000000..518dde5a
--- /dev/null
+++ b/content/tour/blink/external.md
@@ -0,0 +1,131 @@
+---
+title: "External LED"
+description: "Same blinking LED as in the previous example, but now with an external LED."
+weight: 2
+---
+
+Instead of using an on-board LED, you can also connect a LED to an external pin. Just like you see in the example on the right. It connects an external LED (a red one in this case) to the pin A1 on the board.
+
+The code is almost identical to the previous example. The only difference is this line:
+
+```go
+	led := machine.A1
+```
+
+We've replaced the `led` variable: instead of the on-board LED we're now using the external pin A1.
+
+If you want to try this on a development board, make sure you use the correct wiring:
+
+  * Connect the LED cathode (short lead with flat side) to a resistor of around 220Ω-330Ω. Use at least 150Ω to protect the LED, and use at most 1000Ω to still be able to see the LED (higher values will make the LED very dim).
+  * Connect the other end of the resistor to ground.
+  * Connect the LED anode to pin A1 on the board. See the silkscreen on the board or the graphic in the simulator to know which pin this is.
+
+**Warning**: the resistor is not optional, not using the resistor can destroy the LED and/or your board. The LED might even explode!
+
+The simulation doesn't need this resistor because the virtual LED can't burn out. This simplifies the demo, but remember that the real world is messy and LEDs need a resistor. (There are technical reasons for this, read [this answer](https://electronics.stackexchange.com/questions/28393/why-do-we-need-resistors-in-led) for more details).
+
+<script type="module">
+import { setupTour } from '/tour.js';
+let ledConfig = {
+	type: 'led',
+	humanName: 'External LED',
+	color: [255, 0, 0],
+	svg: 'led-tht-5mm.svg',
+};
+let code = `
+// You can edit this code!
+package main
+
+import (
+	"machine"
+	"time"
+)
+
+func main() {
+	led := machine.LED
+	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	for {
+		led.High()
+		time.Sleep(time.Second/2)
+
+		led.Low()
+		time.Sleep(time.Second/2)
+	}
+}`;
+setupTour({
+	boards: {
+		'arduino': {
+			code: code.replace('machine.LED', 'machine.D2 // Arduino Uno'),
+			parts: {
+				led: {
+					config: ledConfig,
+					x: 45,
+					y: -10,
+					rotation: 90,
+				}
+			},
+			wires: [
+				{from: 'main.D2', to: 'led.anode'},
+				{from: 'main.GND#2', to: 'led.cathode'},
+			],
+		},
+		'arduino-nano33': {
+			code: code.replace('machine.LED', 'machine.D2 // Arduino Nano 33 IoT'),
+			parts: {
+				led: {
+					config: ledConfig,
+					x: 12,
+					y: -18,
+				}
+			},
+			wires: [
+				{from: 'main.D2', to: 'led.anode'},
+				{from: 'main.GND#1', to: 'led.cathode'},
+			],
+		},
+		'circuitplay-bluefruit': {
+			code: code.replace('machine.LED', 'machine.A2 // Circuit Playground'),
+			parts: {
+				led: {
+					config: ledConfig,
+					x: 35,
+					y: -4,
+					rotation: 90,
+				}
+			},
+			wires: [
+				{from: 'main.A2', to: 'led.anode'},
+				{from: 'main.GND#1', to: 'led.cathode'},
+			],
+		},
+		'circuitplay-express': {
+			code: code.replace('machine.LED', 'machine.A2 // Circuit Playground'),
+			parts: {
+				led: {
+					config: ledConfig,
+					x: 35,
+					y: -4,
+					rotation: 90,
+				}
+			},
+			wires: [
+				{from: 'main.A2', to: 'led.anode'},
+				{from: 'main.GND#1', to: 'led.cathode'},
+			],
+		},
+		'pico': {
+			code: code.replace('machine.LED', 'machine.GP20 // Raspberry Pi Pico'),
+			parts: {
+				led: {
+					config: ledConfig,
+					x: 16,
+					y: -18,
+				}
+			},
+			wires: [
+				{from: 'main.GP20', to: 'led.anode'},
+				{from: 'main.GND#4', to: 'led.cathode'},
+			],
+		},
+	}});
+</script>
diff --git a/content/tour/blink/onboard.md b/content/tour/blink/onboard.md
new file mode 100644
index 00000000..cfdb6494
--- /dev/null
+++ b/content/tour/blink/onboard.md
@@ -0,0 +1,85 @@
+---
+title: "Blinking LED"
+description: "Hello world of hardware. Blink an on-board LED using your own development board."
+weight: 1
+---
+
+This is the classic "blinking LED" demo you will find in many places. You can find it for the [Arduino IDE](https://docs.arduino.cc/built-in-examples/basics/Blink/) for example. Here is the equivalent in Go.
+
+If you have one of the supported boards (see the dropdown below the code), you can run this code on your own hardware! If you don't, you can just use the simulator that's already running.
+
+Going through the code we can see the following:
+
+```go
+package main
+```
+
+This is just standard Go, so we begin with package main.
+
+```go
+import (
+	"machine"
+	"time"
+)
+```
+
+We import two packages. The time package is the well-known time package which we need to sleep while blinking. However the machine package is new: it is a special standard library package used by TinyGo.
+
+You can think of the machine package like the os or syscall package: it provides an abstraction layer over the underlying hardware and makes code more portable across boards.
+
+```go
+	led := machine.LED
+	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
+```
+
+This configures the LED pin. The constant `LED` is defined in the machine package and represents the pin that is connected to the on-board LED. It is of type `machine.Pin`.
+
+We configure the pin here as an output pin, that is, it outputs either a high or low signal. _High_ or _low_ in this case mean that the output voltage is either somewhere close to the supply voltage (usually 5V or 3.3V) or close to ground (0V).
+
+```go
+	for {
+		led.High()
+		time.Sleep(time.Second/2)
+
+		led.Low()
+		time.Sleep(time.Second/2)
+	}
+```
+
+Here we just blink the LED: we set the output to high for ½ second and then set it to low for ½ second.
+
+Try changing these values and see what happens! For example you can set both to 1 second, or only one of them.
+
+When you play around with the sleep duration, you might discover that "high" and "low" don't actually match the "on" and "off" state of the LED. "high" usually means that the LED is off, while "low" means that it is on. This is because of the way the LED is wired: the anode is connected to the power source (probably via a resistor), and the cathode is connected to the microcontroller pin. This means that when the pin is high (close to the power source) both sides are positive and no current will flow. And when the pin is negative, current will flow from the power source through the LED into the microcontroller. Some boards are wired differently however, and "high" will mean the LED is on while "low" is off.
+
+<script type="module">
+import { setupTour } from '/tour.js';
+setupTour({
+	boards: {
+		'arduino-nano33': {},
+		'arduino': {},
+		'circuitplay-bluefruit': {},
+		'circuitplay-express': {},
+		'pico': {},
+	},
+	code: `
+// You can edit this code!
+package main
+
+import (
+	"machine"
+	"time"
+)
+
+func main() {
+	led := machine.LED
+	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	for {
+		led.High()
+		time.Sleep(time.Second/2)
+
+		led.Low()
+		time.Sleep(time.Second/2)
+	}
+}`});
+</script>
diff --git a/content/tour/button/_index.md b/content/tour/button/_index.md
new file mode 100644
index 00000000..5252a85c
--- /dev/null
+++ b/content/tour/button/_index.md
@@ -0,0 +1,8 @@
+---
+title: "Reading button inputs"
+description: "Make interactive hardware by responding to button presses."
+type: "docs"
+weight: 2
+---
+
+We've seen a blinking LED which provides output, now we're ready for reading from an input.
diff --git a/content/tour/button/external.md b/content/tour/button/external.md
new file mode 100644
index 00000000..1ce3e205
--- /dev/null
+++ b/content/tour/button/external.md
@@ -0,0 +1,162 @@
+---
+title: "External button"
+description: Use an external push button
+weight: 2
+---
+
+This time we'll be blinking an LED, but only when the button is pressed.
+
+If you try it out, you'll see that the LED is initially off (or on), but when you press the button it'll quickly blink. When you release the button, the blinking will stop and it will keep the last state (either on or off).
+
+If you have one of these boards but do not have a pushbutton, you can also use a small wire to connect the given pin (D2/A2/GP2 depending on the board) and then touch a ground point, such as the outside of the USB connector.
+
+
+```go
+	led := machine.LED
+	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
+```
+
+This configures the on-board LED, same as in the [blink example]({{< ref "../blink/onboard.md" >}}).
+
+```go
+	button := machine.D2 // Arduino Uno
+	button.Configure(machine.PinConfig{Mode: machine.PinInputPullup})
+```
+
+This configures the button input. The button pin varies by board, but this time it's always a pullup.
+
+```go
+		// if the button is low (pressed)
+		if !button.Get() {
+			// ...
+		}
+```
+
+Here we check whether the button input is _low_, in other words, whether it is pressed. This is a bit counter intuitive, but that's how it is.
+
+```go
+			// toggle the LED
+			led.Set(!led.Get())
+```
+
+Here we use a trick to toggle the LED: we can actually read the current output value using `led.Get()` and then we can change the value to the opposite value using `led.Set`. This is equivalent to the following:
+
+```go
+			if led.Get() {
+				led.Low()
+			} else {
+				led.High()
+			}
+```
+
+<script type="module">
+import { setupTour } from '/tour.js';
+let buttonConfig = {
+	type: 'pushbutton',
+	humanName: 'Push button',
+	svg: 'pushbutton.svg',
+};
+let code = `
+package main
+
+import (
+	"machine"
+	"time"
+)
+
+func main() {
+	led := machine.LED
+	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
+
+	button := EXT_BUTTON
+	button.Configure(machine.PinConfig{Mode: machine.PinInputPullup})
+
+	for {
+		// if the button is low (pressed)
+		if !button.Get() {
+			// toggle the LED
+			led.Set(!led.Get())
+		}
+
+		// wait a bit, for the blinking effect
+		time.Sleep(100 * time.Millisecond)
+	}
+}`;
+setupTour({
+	boards: {
+		'arduino': {
+			code: code.replace('EXT_BUTTON', 'machine.D2 // Arduino Uno'),
+			parts: {
+				button: {
+					config: buttonConfig,
+					x: 45,
+					y: -10,
+					rotation: 90,
+				},
+			},
+			wires: [
+				{from: 'main.D2', to: 'button.A'},
+				{from: 'main.GND#2', to: 'button.B'},
+			],
+		},
+		'arduino-nano33': {
+			code: code.replace('EXT_BUTTON', 'machine.D2 // Arduino Nano 33 IoT'),
+			parts: {
+				button: {
+					config: buttonConfig,
+					x: 12,
+					y: -18,
+				}
+			},
+			wires: [
+				{from: 'main.D2', to: 'button.A'},
+				{from: 'main.GND#1', to: 'button.B'},
+			],
+		},
+		'circuitplay-bluefruit': {
+			code: code.replace('EXT_BUTTON', 'machine.A2 // Circuit Playground'),
+			parts: {
+				button: {
+					config: buttonConfig,
+					x: 35,
+					y: -4,
+					rotation: 90,
+				}
+			},
+			wires: [
+				{from: 'main.A2', to: 'button.A'},
+				{from: 'main.GND#1', to: 'button.B'},
+			],
+		},
+		'circuitplay-express': {
+			code: code.replace('EXT_BUTTON', 'machine.A2 // Circuit Playground'),
+			parts: {
+				button: {
+					config: buttonConfig,
+					x: 35,
+					y: -4,
+					rotation: 90,
+				}
+			},
+			wires: [
+				{from: 'main.A2', to: 'button.A'},
+				{from: 'main.GND#1', to: 'button.B'},
+			],
+		},
+		'pico': {
+			code: code.replace('EXT_BUTTON', 'machine.GP2 // Raspberry Pi Pico'),
+			parts: {
+				button: {
+					config: buttonConfig,
+					x: -11,
+					y: 18,
+				}
+			},
+			wires: [
+				{from: 'main.GP2', to: 'button.A'},
+				{from: 'main.GND#6', to: 'button.B'},
+			],
+		},
+	},
+});
+</script>
diff --git a/content/tour/button/onboard.md b/content/tour/button/onboard.md
new file mode 100644
index 00000000..9c02c783
--- /dev/null
+++ b/content/tour/button/onboard.md
@@ -0,0 +1,96 @@
+---
+title: "Reading button input"
+description: Learn how to respond to button presses
+weight: 1
+---
+
+Having some output using a LED is nice, but what's even better is if the electronics respond to you!
+
+In this example, we'll use one of the supported boards that have a button on them. If you don't have one of these boards, you can just read the code here and try the next step in the tour where you can connect an external button (or just use a wire).
+
+A lot of code will be familiar from the blinking LED in the previous step, but there are some important differences:
+
+```go
+	button := machine.BUTTONA
+	button.Configure(machine.PinConfig{Mode: machine.PinInputPulldown})
+```
+
+Instead of configuring a LED, we'll configure the pin that's connected to the button labeled 'A' (usually the leftmost button). The mode is `PinInputPullup` or `PinInputPulldown`, the specific mode depends on the board (we'll come back to this later).
+
+```go
+		if button.Get() {
+			println("button input is high")
+		} else {
+			println("button input is low")
+		}
+```
+
+Here we read out the current button state and print whether it was high (`true`) or low (`false`).
+
+You may find that the button pin is normally high but changes to low when pressed, and other boards are the reverse. This depends on how the button is wired, and will be explained later.
+
+## Serial connection
+
+To see the output of the program, you can use a serial monitor. There is a [tutorial for that]({{< ref "serialmonitor.md" >}}). But in short:
+
+  * If you have TinyGo installed, you can open a serial monitor using `tinygo monitor` command. You may need to specify the board, like `tinygo monitor -target=circuitplay-express`.
+  * If you have the Arduino IDE installed, you can use the built-in serial monitor. Make sure to select the right port and to set the baud rate to 115200.
+  * On Linux and MacOS you can use a command-line tool like picocom (which you probably need to install manually).
+  * If you use Windows, Adafruit has a [list of tools you can use](https://learn.adafruit.com/windows-tools-for-the-electrical-engineer/serial-terminal).
+
+## Button wiring
+
+There are many different types of buttons for loads of different applications. The one we're using here is a plain old pushbutton, or a _mometary_, _normally open_ _SPST_ button:
+
+  * _Momentary_ means that you can press it to change state, but when you release it it will revert to its previous state. This is like a keyboard key, and unlike a light switch (which keeps its state).
+  * _Normally open_ means that the connection between the two poles is open (unconnected) when it is not being pressed.
+  * _SPST_ is short for _single-pole, single-throw_ which basically means it's a simple switch with two terminals and two states.
+
+For more information about buttons, please [read this SparkFun article](https://learn.sparkfun.com/tutorials/button-and-switch-basics/all).
+
+For the boards in this tour, one terminal of the button is connected to the pin of the microcontroller and another is connected to either VCC (the power source) or GND (ground, or 0V). This depends on the board.
+
+With this, you can understand that as long as you're pressing the button, the input will be what the button is connected to. For example, if it is connected to GND, you will read `false` as long as you're pressing the button.
+
+But what if you're not pressing the button? It's not connected to ground, but also not to VCC, so what is it? The answer is that it is in an intermediary state called _floating_. Sometimes it reads one way, sometimes another, and it's kind of random which it will do. Even moving your hand around the pin might change the state! Electronic designers will try to avoid this state, by gently pulling the voltage either to ground or to VCC, using a resistor. See the next section.
+
+## Pull mode
+
+To avoid the floating state, microcontrollers have a way to gently pull the voltage one way or another using a built-in resistor. This is why we need either `PinInputPullup` or `PinInputPulldown`. This tells the pin to connect a weak resistor, either between the pin and VCC or between the pin and ground. You can think of it as pulling the voltage either way so it avoids wandering off. Once you press the button, the voltage will be pulled very hard in the other direction so will override the weak pull from the pullup or pulldown resistor.
+
+Sometimes, electronic designers will also put these resistors as physical resistors on the board. This is the case for the Gopher Badge for example. In that case, it is not necessary to specify a pull mode: the hardware already does that. But it won't harm either.
+
+
+<script type="module">
+import { setupTour } from '/tour.js';
+let codePulldown = `
+package main
+
+import (
+	"machine"
+	"time"
+)
+
+func main() {
+	button := machine.BUTTONA
+	button.Configure(machine.PinConfig{Mode: machine.PinInputPulldown})
+
+	for {
+		if button.Get() {
+			println("button input is high")
+		} else {
+			println("button input is low")
+		}
+		time.Sleep(200 * time.Millisecond)
+	}
+}`;
+let codePullup = codePulldown.replace('PinInputPulldown', 'PinInputPullup');
+setupTour({
+	boards: {
+		'circuitplay-bluefruit': { code: codePulldown },
+		'circuitplay-express': { code: codePulldown },
+		'gopher-badge': { code: codePullup.replace('BUTTONA', 'BUTTON_A // Gopher Badge uses BUTTON_A') },
+		'microbit': { code: codePullup },
+	},
+});
+</script>
diff --git a/content/tour/imu/_index.md b/content/tour/imu/_index.md
new file mode 100644
index 00000000..eeb3ed9a
--- /dev/null
+++ b/content/tour/imu/_index.md
@@ -0,0 +1,10 @@
+---
+title: "I2C: Accelerometer"
+type: "docs"
+description: "Learn the I2C protocol by reading the physical orientation using an accelerometer."
+weight: 5
+---
+
+This tour will give an introduction into using I2C devices, using the LIS3DH accelerometer. This is a cheap and low-power accelerometer that is used on a lot of prototyping boards. It explains how to connect to an accelerometer and how to read its values.
+
+Officially these are called I²C devices, but for simplicitly we're using I2C for readability and searchability instead.
diff --git a/content/tour/imu/configure.md b/content/tour/imu/configure.md
new file mode 100644
index 00000000..70f21577
--- /dev/null
+++ b/content/tour/imu/configure.md
@@ -0,0 +1,78 @@
+---
+title: "Configuring the accelerometer"
+description: "Turn on the accelerometer and start reading values"
+weight: 2
+---
+
+The accelerometer that we are using, LIS3DH, starts in a low power mode. That's not the case for all such sensors, many start up in an already enabled state that uses more power. Starting up to a low power mode means that we can ignore the accelerometer when we don't use it and it won't use more power than necessary, but it does mean we need to configure it before we can use it.
+
+The beginning of the code on the right is the same as before, but now we do some magic:
+
+```go
+	err = i2c.Tx(0x18, []byte{0x20, 0b0100_0111}, nil)
+	if err != nil {
+		println("got error while configuring the LIS3DH:", err.Error())
+		return
+	}
+````
+
+That's a lot of magic numbers! Let's go through them:
+
+  * 0x18 is the I2C address, like before. It varies a bit depending on the electronics, but it will always be 0x18 or 0x19 for this particular sensor.
+  * 0x20 is the register address.
+  * 0b0100_0111 (8 bits of binary data) is the value that we're going to write to register 0x20.
+
+Internally, most I2C devices are organized as a number of registers. You can think of it as a slice of bytes, one that's typically just 128 or so bytes long. This slice contains both configuration data (which can typically be read and written), and sensor output data (which is typically read-only). In one transaction, you can either read or write data to the I2C device:
+
+  * For reading, you send a single byte (the register address) to the device and then read the response values into the `r` byte slice. This is what we did in the previous step of this tour, to read the `WHO_AM_I` register.
+  * For writing, you send a slice of bytes to the device and read nothing back. The first byte in the slice is the address, the subsequent bytes are the values to write to the registers starting at the given address. This is what we do above.
+
+To know what register 0x20 is, and what the value 0b0100_0111 means, we need to take another look at the [datasheet](https://cdn-shop.adafruit.com/datasheets/LIS3DH.pdf#page=29):
+
+![Section of the LIS3DH datasheet describing the "CTRL_REG1" register](/images/i2c-lis3dh-config.png)
+
+This section describes register CTRL_REG1 at address 20h. "20h" means "hexadecimal 20", which is the same as 0x20 in Go.
+
+The register itself contains 8 bits: 4 bits for "ODR", one for "LPen", and 3 bits for the three axes (Z, Y, X).
+
+Decoding our value 0b0100_0111 (starting from the lowest bits on the right), we see the following:
+
+  * The lowest 3 bits are the three axes: X, Y, and Z. Of course we want to enable all of them but it is possible to disable some of them if you need. Who knows, it might reduce power usage a little (even though this chip already uses very little power).
+  * The next bit is LPen, or "low power mode enable". This bit is zero, so that means low power mode is disabled (if we enable it, we get less precision from the sensor).
+  * The upper bits, 0100, are the four ODR bits. These four bits are described in table 26 above. Looking at the table, "0 1 0 0" means that we will enable the accelerometer to run at 50Hz (measuring acceleration 50 times per second). This seems like a reasonable speed for our purposes.
+
+Now if you look at the "Properties" tab on the right, you can see that the LIS3DH is indeed configured as "Normal mode 50Hz, enabled axes X, Y, Z", exactly what we wanted! If you go back one step (where we read the `WHO_AM_I` register) you can see it is set to "Power down mode" instead since that is the power-on default. Also, if you go to the "Power" tab, you can see that the LIS3DH now uses 11µA instead of 0.5µA as it did in power down mode.
+
+Try changing the value 0b0100_0111 to something else, and see what happens in the simulator!
+
+<script type="module">
+let code = `
+package main
+
+import (
+	"machine"
+)
+
+func main() {
+	i2c := machine.I2C0
+	err := i2c.Configure(machine.I2CConfig{
+		SCL: machine.SCL_PIN,
+		SDA: machine.SDA_PIN,
+	})
+	if err != nil {
+		println("could not configure I2C:", err.Error())
+		return
+	}
+
+	err = i2c.Tx(0x18, []byte{0x20, 0b0100_0111}, nil)
+	if err != nil {
+		println("got error while configuring the LIS3DH:", err.Error())
+		return
+	}
+
+	println("accelerometer configured!")
+}
+`;
+import {setupLIS3DH} from "/tour-lis3dh.js";
+setupLIS3DH(code);
+</script>
diff --git a/content/tour/imu/connected.md b/content/tour/imu/connected.md
new file mode 100644
index 00000000..2bb68178
--- /dev/null
+++ b/content/tour/imu/connected.md
@@ -0,0 +1,90 @@
+---
+title: "Get started with I2C"
+description: "Get started with the LIS3DH by verifying the connection."
+weight: 1
+---
+
+The LIS3DH sensor can measure acceleration and changes in temperature. But to get this data from the sensor, we need a way to establish communication. We'll be using the I2C protocol, which is the most common way to communicate with low-speed external devices.
+
+```go
+	i2c := machine.I2C0
+	err := i2c.Configure(machine.I2CConfig{
+		SCL: machine.GP17,
+		SDA: machine.GP16,
+	})
+```
+
+To start using I2C, we need to configure I2C on the microcontroller. This code (for the Raspberry Pi Pico) configures GP17 and GP16 as the pins to be used. Note that you can't use all pins! Many microcontrollers only allow using specific pins for I2C. We'll get to that later.
+
+```go
+		w := []byte{0x0f}
+		r := make([]byte, 1)
+		err := i2c.Tx(0x18, w, r)
+```
+
+This does an actual transaction. This code will first write the I2C peripheral address (0x18 or 0x19 depending on the electronic design), then write the byte 0x0f in the `w` byte slice, and then read a single byte back to store in the `r` byte slice. The peripheral address is the one for the LIS3DH, and 0x0f is a register called `WHO_AM_I` which when read returns a fixed value to identify the chip.
+
+![WHO_AM_I register description, with the bits in the register being "0 0 1 1 0 0 1 1"](/images/lis3dh-who-am-i.png)
+
+Here is the description from the [datasheet](https://cdn-shop.adafruit.com/datasheets/LIS3DH.pdf#page=29). It says the returned bits are "0 0 1 1 0 0 1 1". Decoding this to decimal, we get the number 51. And that's exactly what we get back from the chip, which shows that we managed to communicate with the chip!
+
+
+## Connecting I2C devices
+
+I2C uses two wires to communicate: a clock wire (SCL) and a data wire (SDA). Connect the SCL pin on the microcontroller to the SCL pin on the sensor, and the SDA pin on the microcontroller to the SDA pin on the sensor. Also, make sure there is a ground connection between the two, otherwise communication won't work!
+
+Apart from SCL and SDA (and a shared ground), the sensor also needs some power. This is often 3.3V, but check the datasheet to be sure. If the sensor needs 3.3V and you provide it 5V, it will likely burn out! In the simulator we skip this requirement to avoid clutter.
+
+I2C may also need some external pullup registers, that make sure the wires stay high unless they are set to a low voltage by the controlling device. In practice, many sensors already include pullup resistors and microcontrollers often configure I2C wires with a pullup, so this may not be required in practice. It's something to be aware of when you design your own board though.
+
+## I2C basics
+
+I2C allows using multiple devices with just one pair of wires! This pair of wires (SCL and SDA) is called a bus, and can be connected to multiple sensors and actuators. It typically only allows one controlling device (the main microcontroller), but on this bus up to 127 or so devices can be used. These are usually sensors or other low-speed devices, but you can also configure another microcontroller as a peripheral device to allow communication with the controlling device.
+
+To support multiple devices on a single bus, every I2C peripheral device has an address. In the case of the LIS3DH, that is 0x18 or 0x19 in hexadecimal. You can change the address by connecting the SA0/SDO pin to VCC or GND.
+
+Communication is always initiated from the controller device (typically the microcontroller), and happens in a single transaction with a peripheral device. The controller sends the address, then sends a few bytes (which can be zero-length), and then receives a number of bytes. That all happens in a single operation called a "transaction".
+
+In other documentation you may see the term "master" and "slave", but we chose to use the [less problematic](https://oshwa.org/resources/a-resolution-to-redefine-spi-signal-names/) "controller" and "peripheral" instead.
+
+As usual, [SparkFun has an excellent article explaining all the ins and outs of I2C](https://learn.sparkfun.com/tutorials/i2c/all) if you want to learn more.
+
+
+<script type="module">
+let code = `
+package main
+
+import (
+	"machine"
+	"time"
+)
+
+func main() {
+	i2c := machine.I2C0
+	err := i2c.Configure(machine.I2CConfig{
+		SCL: machine.SCL_PIN,
+		SDA: machine.SDA_PIN,
+	})
+	if err != nil {
+		println("could not configure I2C:", err.Error())
+		return
+	}
+
+	for {
+		// Read the "who am I" register.
+		w := []byte{0x0f}
+		r := make([]byte, 1)
+		err := i2c.Tx(0x18, w, r)
+		if err != nil {
+			println("got error while reading 'who am I' register:", err.Error())
+		} else {
+			println("chip says:", r[0])
+		}
+
+		time.Sleep(time.Second)
+	}
+}
+`;
+import {setupLIS3DH} from "/tour-lis3dh.js";
+setupLIS3DH(code);
+</script>
diff --git a/content/tour/imu/reading.md b/content/tour/imu/reading.md
new file mode 100644
index 00000000..67b76076
--- /dev/null
+++ b/content/tour/imu/reading.md
@@ -0,0 +1,93 @@
+---
+title: "Reading acceleration values"
+description: "Read the X, Y, and Z values from the accelerometer."
+weight: 3
+---
+
+Now that we have the accelerometer configured, we can start reading the values it reads.
+
+Most of the code is the same as before, but the reading part is new:
+
+```go
+		// Read the acceleration data.
+		w := []byte{0x28|0x80}
+		r := make([]byte, 6)
+		err := i2c.Tx(0x18, w, r)
+```
+
+Here we read 6 bytes starting with register 0x28. We'll get back to why we need to set the highest bit later (through `|0x80`). First let's take a look at the [datasheet](https://cdn-shop.adafruit.com/datasheets/LIS3DH.pdf#page=33) again:
+
+![...](/images/i2c-lis3dh-acceldata.png)
+
+So here we have 6 registers that contain the acceleration data in the 3 directions (X, Y, Z) where each direction takes up two registers. Since each register is 8 bits, and the data itself is 10 bits, two registers are needed for each direction.
+
+Decoding it is a little bit tricky though, if you're not used to bitwise operations:
+
+```go
+			x := int16(r[0]) | int16(r[1])<<8
+			y := int16(r[2]) | int16(r[3])<<8
+			z := int16(r[4]) | int16(r[5])<<8
+			println("x, y, z:", x, y, z)
+````
+
+This combines the two 8 bit values into a single 16-bit signed integer. If we take the X axis for example, the datasheet implies the first register (`OUT_X_L`) is low, since it has "L" in the name. (Yes, it's not the most helpful datasheet in this regard). The next register (`OUT_X_H`) contains the upper bits. So the way to convert them to a single 16-bit value is to convert them both individually to a 16-bit value (which keeps the lower bits but fills the missing bits with zero), then _shift_ the bits of `OUT_X_H` to the high position, and OR them together. This gives us a single 16-bit value, which is the signed X axis.
+
+On the right you can see the values we read from the accelerometer. On a desktop computer you will see simulated values, as if the board is lying flat on a surface. However, if you are on a supported mobile device (phone, table), you will actually be able to see the real acceleration values of your device!
+
+Some things to note:
+
+  * **Gravity** is also measured. This is just how physics works: when the sensor is lying still, it shows values as if it was accelerating at *g* speed away from earth. (Unless you're doing this in a zero-gravity environment, of course). There are various algorithms to filter out the gravity component, which will usually be needed for practical applications.
+  * There is **noise** in the output. Every sensor has noise, this one included. The simulator includes the noise to be more realistic, and if you use such a sensor in a project you need to be aware that such noise exists.
+  * The sensor can be put on a board in various ways, for example it can either be on top or at the bottom. This will of course impact the measurements.
+
+## What's up with that upper bit?
+
+While for I2C devices you can read multiple sequential registers by writing the register address and then reading multiple values back, the LIS3DH is a bit different. By default it will return the same register on every read. To get the behavior we want, we need to set the highest bit of the register address to one, which gets the sensor to return values incrementally.
+
+<script type="module">
+let code = `
+package main
+
+import (
+	"machine"
+	"time"
+)
+
+func main() {
+	i2c := machine.I2C0
+	err := i2c.Configure(machine.I2CConfig{
+		SCL: machine.SCL_PIN,
+		SDA: machine.SDA_PIN,
+	})
+	if err != nil {
+		println("could not configure I2C:", err.Error())
+		return
+	}
+
+	err = i2c.Tx(0x18, []byte{0x20, 0b0100_0111}, nil)
+	if err != nil {
+		println("got error while configuring the LIS3DH:", err.Error())
+		return
+	}
+
+	for {
+		// Read the acceleration data.
+		w := []byte{0x28|0x80}
+		r := make([]byte, 6)
+		err := i2c.Tx(0x18, w, r)
+		if err != nil {
+			println("got error while reading values:", err.Error())
+		} else {
+			x := int16(r[0]) | int16(r[1])<<8
+			y := int16(r[2]) | int16(r[3])<<8
+			z := int16(r[4]) | int16(r[5])<<8
+			println("x, y, z:", x, y, z)
+		}
+
+		time.Sleep(time.Second)
+	}
+}
+`;
+import {setupLIS3DH} from "/tour-lis3dh.js";
+setupLIS3DH(code);
+</script>
diff --git a/content/tour/pwm/_index.md b/content/tour/pwm/_index.md
new file mode 100644
index 00000000..48cf8fcf
--- /dev/null
+++ b/content/tour/pwm/_index.md
@@ -0,0 +1,8 @@
+---
+title: "PWM"
+description: "Using the PWM peripheral of common microcontrollers."
+type: "docs"
+weight: 4
+---
+
+PWM, or Pulse Width Modulation, is a deceptively simple but very powerful technique for controlling various things in the real world. Perhaps the most well known application is dimming LEDs, but PWM can also be used to control servo motors and producing crude (square wave) tones on speakers.
diff --git a/content/tour/pwm/blink.md b/content/tour/pwm/blink.md
new file mode 100644
index 00000000..2fc86d5c
--- /dev/null
+++ b/content/tour/pwm/blink.md
@@ -0,0 +1,112 @@
+---
+title: "LED: blink"
+description: "Get a LED to blink using the PWM peripheral."
+weight: 1
+---
+
+PWM, or pulse-width modulation, is a method of turning a GPIO pin high and low at a fixed frequency but changing the percent of time it is turned on. This has numerous applications, such as dimming LEDs. We'll see various applications of PWM throughout this tour.
+
+To start off with, we're going to do something slightly unusual with PWM: we're going to blink an LED. Remember that PWM is a way of quickly turning an output high and low, if we do that slow enough we can see the LED blink. This should make it easier to see how PWM works.
+
+At first we'll just define some variables. These may vary by board, so it's useful to define them in a single place.
+
+```go
+	// Board specific configuration.
+	led := machine.LED
+	pwm := machine.TCC0
+```
+
+Next we're going to configure the PWM peripheral itself:
+
+```go
+	// Configure the timer/PWM.
+	err := pwm.Configure(machine.PWMConfig{
+		Period: 2e9, // two seconds for a single cycle
+	})
+	if err != nil {
+		println("could not configure:", err.Error())
+		return
+	}
+```
+
+This configures the PWM peripheral for a cycle time of two seconds. That's much longer than PWM is commonly used for, but it allows to see us what happens.
+
+Next up, we connect the PWM peripheral to the given output pin:
+
+```go
+	// Get the channel for this PWM peripheral.
+	ch, err := pwm.Channel(led)
+	if err != nil {
+		println("could not obtain channel:", err.Error())
+		return
+	}
+```
+
+We get a channel number back. One PWM peripheral typically has 2-4 channels, which can be connected to certain pins. Which pins can be used depends a lot on the hardware, which we'll [get to later](../multiple/#finding-the-correct-pwm-peripheral-and-pins). For now, all you need to know is that the PWM channel is now connected to a single GPIO pin.
+
+To actually make the LED blink, we will need to set the duty cycle. The duty cycle refers to the part of the time when the PWM is turned on. In this case, we will set the duty cycle to half the "top" value of the LED:
+
+```go
+	// Blink the LED, setting it to "on" half the time.
+	pwm.Set(ch, pwm.Top()/2)
+```
+
+The top value is equivalent to a duty cycle of 100% - or 100% of the time on. So using the top divided by 2 results in a duty cycle of 50%, or "high" for half the time. Dividing by 3 results in a duty cycle of 33%, etc. By varying the formula you can either use a particular percentage (like we do here) or if you know the period size you can calculate a specific "on" time within the cycle (such as "500ms on, 2000ms off").
+
+To get a feel for how it works, you can try a few things:
+
+  * You can change the period to something other than `2e9` (two seconds) and see what happens to the "top" value.
+  * You can change the duty cycle by changing the `pwm.Set` call.
+  * You can connect a different LED to the virtual board, and blink it.
+  * You can try using a different PWM peripheral. These boards also have `TCC1` and `TCC2`.
+
+## More information
+
+SparkFun has written an [excellent tutorial on PWM](https://learn.sparkfun.com/tutorials/pulse-width-modulation) that is well worth a read!
+
+
+
+<script type="module">
+import { setupTour } from '/tour.js';
+let code = `
+package main
+
+import "machine"
+
+func main() {
+	// Board specific configuration.
+	led := machine.LED
+	pwm := machine.TCC0
+
+	// Configure the timer/PWM.
+	err := pwm.Configure(machine.PWMConfig{
+		Period: 2e9, // two seconds for a single cycle
+	})
+	if err != nil {
+		println("could not configure:", err.Error())
+		return
+	}
+
+	// Get the channel for this PWM peripheral.
+	ch, err := pwm.Channel(led)
+	if err != nil {
+		println("could not obtain channel:", err.Error())
+		return
+	}
+
+	// Blink the LED, setting it to "on" half the time.
+	pwm.Set(ch, pwm.Top()/2)
+
+	println("top value:  ", pwm.Top())
+	println("LED channel:", ch)
+
+	// Main returns, so the program exits. Yet the LED continues blinking.
+}
+`;
+setupTour({
+	code: code,
+	boards: {
+		'arduino-nano33': {},
+		'circuitplay-express': {},
+	}});
+</script>
diff --git a/content/tour/pwm/fade.md b/content/tour/pwm/fade.md
new file mode 100644
index 00000000..b20d8fd2
--- /dev/null
+++ b/content/tour/pwm/fade.md
@@ -0,0 +1,93 @@
+---
+title: "LED: fade"
+description: "Fade a LED using the PWM peripheral."
+weight: 2
+---
+
+Next up, we're going to do what PWM was actually designed for! Namely, quickly controlling an output so that the average output can be controlled precisely.
+
+Most of it is similar to blinking an LED using the PWM peripheral, but fading needs a little bit more work:
+
+```go
+		// Fade the LED in.
+		for percentOn := 0; percentOn <= 100; percentOn++ {
+			pwm.Set(ch, pwm.Top()*uint32(percentOn)/100)
+			time.Sleep(time.Second / 100)
+		}
+```
+
+Here we fade the LED in. This loop loops 101 times (from 0 to 100 inclusive), setting the output to a percentage of the input. The code `pwm.Top()*uint32(percentOn)/100` is essentially the integer variant of the following formula:
+
+```math
+\frac{T}{100} * P
+```
+
+Where \\(T\\) is the top value (`pwm.Top()`) and \\(P\\) is the percentage (`percentOn`).
+
+Fading out is very similar. It's almost identical, except it loops from 100 to 0 (inclusive):
+
+```go
+		// Fade the LED out.
+		for percentOn := 100; percentOn >= 0; percentOn-- {
+			pwm.Set(ch, pwm.Top()*uint32(percentOn)/100)
+			time.Sleep(time.Second / 100)
+		}
+```
+
+
+<script type="module">
+import { setupTour } from '/tour.js';
+let code = `
+package main
+
+import "machine"
+import "time"
+
+func main() {
+	// Board specific configuration.
+	led := machine.LED
+	pwm := machine.TCC0
+
+	// Configure the timer/PWM.
+	// Use the default period, which works well enough for LEDs.
+	err := pwm.Configure(machine.PWMConfig{})
+	if err != nil {
+		println("could not configure:", err.Error())
+		return
+	}
+
+	// Get the channel for this PWM peripheral.
+	ch, err := pwm.Channel(led)
+	if err != nil {
+		println("could not obtain channel:", err.Error())
+		return
+	}
+
+	for {
+		// Fade the LED in.
+		for percentOn := 0; percentOn <= 100; percentOn++ {
+			pwm.Set(ch, pwm.Top()*uint32(percentOn)/100)
+			time.Sleep(time.Second / 100)
+		}
+
+		// Fade the LED out.
+		for percentOn := 100; percentOn >= 0; percentOn-- {
+			pwm.Set(ch, pwm.Top()*uint32(percentOn)/100)
+			time.Sleep(time.Second / 100)
+		}
+	}
+}
+`;
+setupTour({
+	code: code,
+	boards: {
+		'arduino-nano33': {},
+		'circuitplay-bluefruit': {
+			code: code.replace('machine.TCC0', 'machine.PWM0'),
+		},
+		'circuitplay-express': {},
+		'pico': {
+			code: code.replace('machine.TCC0', 'machine.PWM4'),
+		},
+	}});
+</script>
diff --git a/content/tour/pwm/multiple.md b/content/tour/pwm/multiple.md
new file mode 100644
index 00000000..8ead7dc0
--- /dev/null
+++ b/content/tour/pwm/multiple.md
@@ -0,0 +1,192 @@
+---
+title: "LED: fade multiple"
+description: "Control multiple channels from a single PWM peripheral by making use of channels."
+weight: 3
+---
+
+One PWM peripheral can be used to control multiple LEDs as well, by using different channels. In that case, the frequency (or period) will be the same for all LEDs, but the duty cycle (percent on) will vary per channel and therefore per LED.
+
+On the right, we have a single PWM instance but we use two goroutines to fade both LEDs in and out. Both LEDs are using a different PWM channel.
+
+## Finding the correct PWM peripheral and pins
+
+You may be wondering how we picked the right PWM peripheral and pins? It's actually all in the documentation if you know where to look:
+
+  * [Arduino Nano 33 IoT](/docs/reference/microcontrollers/arduino-nano33/#pins)
+  * [Adafruit Circuit Playground Bluefruit](/docs/reference/microcontrollers/circuitplay-bluefruit/#pins) (special case, see below)
+  * [Adafruit Circuit Playground Express](/docs/reference/microcontrollers/circuitplay-express/#pins)
+  * [Raspberry Pi Pico](/docs/reference/microcontrollers/pico/#pins)
+
+Let's look at the first, the Arduino Nano 33 IoT. In the Pins table, there are these two rows:
+
+> | Pin               | Hardware pin | Alternative names | PWM                  |
+> | ----------------- | ------------ | ----------------- | -------------------- |
+> | `A2`              | `PA11`       |                   | `TCC1` (channel 1), `TCC0` (channel 3) |
+> | `A3`              | `PA10`       | `I2S_SCK_PIN`     | `TCC1` (channel 0), `TCC0` (channel 2) |
+
+In this table you can see that we actually could have used two different PWM peripherals! Either TCC1 or TCC0. Both are supported for both pins, and importantly both use different channels for each pin. For TCC1 (as used on the right) channel 1 and 0 are used, while for TCC0 channel 2 and 3 would have been used.
+
+Question: can you verify that the peripheral used for the other 3 boards corresponds to the PWM peripheral and channel used in the simulator on the right?
+
+You might have noticed that three out of the four boards list PWMs, but one does not: the Circuit Playground Bluefruit. This is because the PWM peripherals on this chip can be connected to any pin. So what happens instead is that the `machine.PWM` type will not look up the pin in a table or something, but will instead use the first available unused channel. This brings a lot of flexibility, especially when you are working with special device types like servos (which will be addressed later in this tour).
+
+
+<script type="module">
+import { setupTour } from '/tour.js';
+let code = `
+package main
+
+import "machine"
+import "time"
+
+// Board specific configuration.
+var pwm = machine.TCC1
+
+func main() {
+	// Configure the timer/PWM.
+	// Use the default period, which works well enough for LEDs.
+	err := pwm.Configure(machine.PWMConfig{})
+	if err != nil {
+		println("could not configure:", err.Error())
+		return
+	}
+
+	// Now fade both LEDs in and out.
+	go fadeLED(machine.A2, time.Millisecond*1000)
+	fadeLED(machine.A3, time.Millisecond*1300)
+}
+
+func fadeLED(led machine.Pin, duration time.Duration) {
+	// Get the channel for this PWM peripheral.
+	ch, err := pwm.Channel(led)
+	if err != nil {
+		println("could not obtain channel:", err.Error())
+		return
+	}
+
+	println("fading a LED on channel", ch, "every", duration.String())
+
+	for {
+		// Fade the LED in.
+		for percentOn := 0; percentOn <= 100; percentOn++ {
+			pwm.Set(ch, pwm.Top()*uint32(percentOn)/100)
+			time.Sleep(duration / 202)
+		}
+
+		// Fade the LED out.
+		for percentOn := 100; percentOn >= 0; percentOn-- {
+			pwm.Set(ch, pwm.Top()*uint32(percentOn)/100)
+			time.Sleep(duration / 202)
+		}
+	}
+}
+`;
+let ledConfig1 = {
+	type: 'led',
+	humanName: 'External LED 1',
+	color: [255, 0, 0],
+	svg: 'led-tht-5mm.svg',
+};
+let ledConfig2 = {
+	type: 'led',
+	humanName: 'External LED 2',
+	color: [255, 0, 0],
+	svg: 'led-tht-5mm.svg',
+};
+setupTour({
+	code: code,
+	boards: {
+		'arduino-nano33': {
+			parts: {
+				main: {
+					y: -8,
+				},
+				led1: {
+					config: ledConfig1,
+					x: 0,
+					y: 12,
+				},
+				led2: {
+					config: ledConfig2,
+					x: 14,
+					y: 12,
+				}
+			},
+			wires: [
+				{from: 'main.A2', to: 'led1.anode'},
+				{from: 'main.A3', to: 'led2.anode'},
+				{from: 'main.GND#2', to: 'led1.cathode'},
+				{from: 'main.GND#2', to: 'led2.cathode'},
+			],
+		},
+		'circuitplay-bluefruit': {
+			code: code.replace('machine.TCC1', 'machine.PWM0'),
+			parts: {
+				led1: {
+					config: ledConfig1,
+					x: 35,
+					y: -8,
+					rotation: 90,
+				},
+				led2: {
+					config: ledConfig2,
+					x: 45,
+					y: -8,
+					rotation: 90,
+				}
+			},
+			wires: [
+				{from: 'main.A2', to: 'led1.anode'},
+				{from: 'main.A3', to: 'led2.anode'},
+				{from: 'main.GND#1', to: 'led1.cathode'},
+				{from: 'main.GND#1', to: 'led2.cathode'},
+			],
+		},
+		'circuitplay-express': {
+			parts: {
+				led1: {
+					config: ledConfig1,
+					x: 35,
+					y: -8,
+					rotation: 90,
+				},
+				led2: {
+					config: ledConfig2,
+					x: 45,
+					y: -8,
+					rotation: 90,
+				}
+			},
+			wires: [
+				{from: 'main.A2', to: 'led1.anode'},
+				{from: 'main.A3', to: 'led2.anode'},
+				{from: 'main.GND#1', to: 'led1.cathode'},
+				{from: 'main.GND#1', to: 'led2.cathode'},
+			],
+		},
+		'pico': {
+			code: code.replace('machine.TCC1', 'machine.PWM1').replace('machine.A2', 'machine.GP2').replace('machine.A3', 'machine.GP3'),
+			parts: {
+				main: {
+					y: -8,
+				},
+				led1: {
+					config: ledConfig1,
+					x: -16,
+					y: 12,
+				},
+				led2: {
+					config: ledConfig2,
+					x: -3,
+					y: 12,
+				}
+			},
+			wires: [
+				{from: 'main.GP2', to: 'led1.anode'},
+				{from: 'main.GP3', to: 'led2.anode'},
+				{from: 'main.GND#6', to: 'led1.cathode'},
+				{from: 'main.GND#6', to: 'led2.cathode'},
+			],
+		},
+	}});
+</script>
diff --git a/content/tour/pwm/servo-driver.md b/content/tour/pwm/servo-driver.md
new file mode 100644
index 00000000..1c3fdf9f
--- /dev/null
+++ b/content/tour/pwm/servo-driver.md
@@ -0,0 +1,159 @@
+---
+title: "Servo: using a driver"
+description: "Control a servo motor using the servo driver to simplify things."
+weight: 11
+---
+
+In many cases, it would be nice to avoid having to care about all these specific calculations. Luckily we have the [servo driver](https://pkg.go.dev/tinygo.org/x/drivers/servo) as part of the TinyGo drivers module. It still requires looking up the right PWM and pin combinations, but it does simplify controlling the servos a bit.
+
+To use the driver, we need to configure it first:
+
+```go
+	// Configure the servo array.
+	array, err := servo.NewArray(pwm)
+	if err != nil {
+		println("could not configure:", err.Error())
+		return
+	}
+```
+
+We just pass in the PWM peripheral, and it will configure the PWM to the right period size. Note it is called an "array" since we can actually control multiple servos! More on that later.
+
+Next, we can configure the servo array to use this servo:
+
+```go
+	// Add a servo to the servo array.
+	servo, err := array.Add(servoPin)
+	if err != nil {
+		println("could not add servo pin:", err.Error())
+		return
+	}
+```
+
+This will configure the pin to be used as a servo pin, and returns a `servo.Servo` instance. This instance can then be used to set the servo angle:
+
+```go
+	// Left position at 2000µs (2ms) "on" time.
+	println("left:  -90°")
+	servo.SetMicroseconds(2000)
+	time.Sleep(time.Second * 3)
+```
+
+
+<script type="module">
+import { setupTour } from '/tour.js';
+let code = `
+package main
+
+import "machine"
+import "time"
+import "tinygo.org/x/drivers/servo"
+
+func main() {
+	// Board specific configuration.
+	servoPin := machine.GP16
+	pwm := machine.PWM0
+
+	// Configure the servo array.
+	array, err := servo.NewArray(pwm)
+	if err != nil {
+		println("could not configure:", err.Error())
+		return
+	}
+
+	// Add a servo to the servo array.
+	servo, err := array.Add(servoPin)
+	if err != nil {
+		println("could not add servo:", err.Error())
+		return
+	}
+
+	// Left position at 2000µs (2ms) "on" time.
+	println("left:  -90°")
+	servo.SetMicroseconds(2000)
+	time.Sleep(time.Second * 3)
+
+	// Right position, at 1000µs (1ms) "on" time.
+	println("right: +90°")
+	servo.SetMicroseconds(1000)
+	time.Sleep(time.Second * 3)
+
+	// Center position, at 1500µs (1.5ms) "on" time.
+	println("center: 0°")
+	servo.SetMicroseconds(1500)
+	time.Sleep(time.Second * 3)
+}
+`;
+let servoConfig = {
+	type: 'servo',
+	humanName: 'Servo',
+	svg: 'servo-sg90.svg',
+};
+setupTour({
+	boards: {
+		'arduino-nano33': {
+			code: code.replace('machine.PWM0', 'machine.TCC0').replace('machine.GP16', 'machine.D2'),
+			parts: {
+				main: {
+					y: 15,
+				},
+				servo: {
+					config: servoConfig,
+					x: 0,
+					y: -12,
+				},
+			},
+			wires: [
+				{from: 'main.D2', to: 'servo.control'},
+			],
+		},
+		'circuitplay-bluefruit': {
+			code: code.replace('machine.GP16', 'machine.A1'),
+			parts: {
+				main: {
+					x: -25,
+				},
+				servo: {
+					config: servoConfig,
+					x: 25,
+					y: -10,
+				},
+			},
+			wires: [
+				{from: 'main.A1', to: 'servo.control'},
+			],
+		},
+		'circuitplay-express': {
+			code: code.replace('machine.PWM0', 'machine.TCC0').replace('machine.GP16', 'machine.A1'),
+			parts: {
+				main: {
+					x: -25,
+				},
+				servo: {
+					config: servoConfig,
+					x: 25,
+					y: -10,
+				},
+			},
+			wires: [
+				{from: 'main.A1', to: 'servo.control'},
+			],
+		},
+		'pico': {
+			code: code,
+			parts: {
+				main: {
+					y: 15,
+				},
+				servo: {
+					config: servoConfig,
+					x: 0,
+					y: -12,
+				},
+			},
+			wires: [
+				{from: 'main.GP16', to: 'servo.control'},
+			],
+		},
+	}});
+</script>
diff --git a/content/tour/pwm/servo-multiple.md b/content/tour/pwm/servo-multiple.md
new file mode 100644
index 00000000..f9f96c0d
--- /dev/null
+++ b/content/tour/pwm/servo-multiple.md
@@ -0,0 +1,163 @@
+---
+title: "Servo: multiple servos"
+description: "Control multiple servos at once"
+weight: 12
+---
+
+Since many PWM peripherals have multiple channels (usually 2 or 4) we can in fact control multiple servos using a single PWM peripheral (freeing up other PWM peripherals for other tasks). This is why it's called `servo.NewArray`!
+
+The code is very similar to using a single servo, but this time we control more than one from different goroutines. If you need more servos, you can of course use more than one servo array with different PWM peripherals.
+
+
+<script type="module">
+import { setupTour } from '/tour.js';
+let code = `
+package main
+
+import "machine"
+import "time"
+import "tinygo.org/x/drivers/servo"
+
+func main() {
+	// Board specific configuration.
+	servoPin1 := machine.GP16
+	servoPin2 := machine.GP17
+	pwm := machine.PWM0
+
+	// Configure the servo array.
+	array, err := servo.NewArray(pwm)
+	if err != nil {
+		println("could not configure:", err.Error())
+		return
+	}
+
+	// Add both servos to the servo array.
+	servo1, err := array.Add(servoPin1)
+	if err != nil {
+		println("could not add servo 1:", err.Error())
+		return
+	}
+	servo2, err := array.Add(servoPin2)
+	if err != nil {
+		println("could not add servo 2:", err.Error())
+		return
+	}
+
+	go moveServo(servo2, 1300*time.Millisecond)
+	moveServo(servo1, 1000*time.Millisecond)
+}
+
+func moveServo(s servo.Servo, delay time.Duration) {
+	for {
+		// Move down.
+		s.SetMicroseconds(1000)
+		time.Sleep(delay)
+
+		// Move up.
+		s.SetMicroseconds(1500)
+		time.Sleep(delay)
+	}
+}
+`;
+let servoConfig1 = {
+	type: 'servo',
+	humanName: 'Servo 1',
+	svg: 'servo-sg90.svg',
+};
+let servoConfig2 = {
+	type: 'servo',
+	humanName: 'Servo 2',
+	svg: 'servo-sg90.svg',
+};
+setupTour({
+	boards: {
+		'arduino-nano33': {
+			code: code.replace('machine.PWM0', 'machine.TCC0').replace('machine.GP16', 'machine.D2').replace('machine.GP17', 'machine.D3'),
+			parts: {
+				main: {
+					x: 30,
+				},
+				servo1: {
+					config: servoConfig1,
+					x: -30,
+					y: -12,
+				},
+				servo2: {
+					config: servoConfig2,
+					x: -30,
+					y: 12,
+				},
+			},
+			wires: [
+				{from: 'main.D2', to: 'servo1.control'},
+				{from: 'main.D3', to: 'servo2.control'},
+			],
+		},
+		'circuitplay-bluefruit': {
+			code: code.replace('machine.GP16', 'machine.A2').replace('machine.GP17', 'machine.A1'),
+			parts: {
+				main: {
+					x: 30,
+				},
+				servo1: {
+					config: servoConfig1,
+					x: -25,
+					y: -12,
+				},
+				servo2: {
+					config: servoConfig2,
+					x: -25,
+					y: 12,
+				},
+			},
+			wires: [
+				{from: 'main.A2', to: 'servo1.control'},
+				{from: 'main.A1', to: 'servo2.control'},
+			],
+		},
+		'circuitplay-express': {
+			code: code.replace('machine.PWM0', 'machine.TCC1').replace('machine.GP16', 'machine.A3').replace('machine.GP17', 'machine.A2'),
+			parts: {
+				main: {
+					x: 25,
+				},
+				servo1: {
+					config: servoConfig1,
+					x: -25,
+					y: -12,
+				},
+				servo2: {
+					config: servoConfig2,
+					x: -25,
+					y: 12,
+				},
+			},
+			wires: [
+				{from: 'main.A3', to: 'servo1.control'},
+				{from: 'main.A2', to: 'servo2.control'},
+			],
+		},
+		'pico': {
+			code: code,
+			parts: {
+				main: {
+					x: 30,
+				},
+				servo1: {
+					config: servoConfig1,
+					x: -30,
+					y: -12,
+				},
+				servo2: {
+					config: servoConfig2,
+					x: -30,
+					y: 12,
+				},
+			},
+			wires: [
+				{from: 'main.GP16', to: 'servo1.control'},
+				{from: 'main.GP17', to: 'servo2.control'},
+			],
+		},
+	}});
+</script>
diff --git a/content/tour/pwm/servo.md b/content/tour/pwm/servo.md
new file mode 100644
index 00000000..a8a6da36
--- /dev/null
+++ b/content/tour/pwm/servo.md
@@ -0,0 +1,183 @@
+---
+title: "Servo: intro"
+description: "Control a servo motor directly using PWM"
+weight: 10
+---
+
+Servos are rotary motors that allow for precise control of their angular position. The position is set using a form of pulse-width modification (PWM). Every 20ms or so (the precise interval doesn't matter too much) a pulse of 1ms to 2ms is sent that indicates the target position for the motor. The pulse width is what matters here: 1.5ms indicates the center position, 1ms all the way to the right, and 2ms all the way to the left.
+
+There is a decent amount of variation among servo motors:
+
+  * Servos generally accept a wider range of pulse intervals, 20ms is standard but it doesn't matter too much.
+  * The usual range is 1ms to 2ms, but many servos accept a somewhat larger range from about 0.8ms to 2.2ms. Be careful with this: putting a servo out of range will let it keep trying to reach that position (which it can't) which will quickly wear out the motor!
+  * Different servos have different ranges. Typical ranges are 90° and 180°, the simulator has a 180° servo.
+
+So we need to send very precisely timed pulses every 20ms. That's exactly the sort of thing the built-in PWM is made for! Here is how we can do that:
+
+  * Configure the PWM peripheral to use a period of 20ms.
+  * Configure a channel/pin to be used for the servo.
+  * Set the channel to a duty cycle that matches the 1-2ms range.
+
+This is exactly what the code on the right is doing. Let's look at setting the servo in a specific position:
+
+```go
+	// Left position at 2000µs (2ms) "on" time.
+	println("left:  -90°")
+	pwm.Set(ch, pwm.Top()*20/200)
+	time.Sleep(time.Second * 3)
+```
+
+We see it uses the following formula for calculating the duty cycle:
+
+```math
+\frac{T*20}{200}
+```
+
+Simplifying, we get:
+
+```math
+\frac{T}{10}
+```
+
+In other words, the 20ms period is divided by 10 to get an "on" time of 2ms: exactly what we wanted! The fractions for 1ms (all the way to the right) and 1.5ms (center position) are the same.
+
+Because servos aren't instantaneous, we do need to wait a bit for the change to take effect:
+
+```go
+	time.Sleep(time.Second * 3)
+```
+
+3 seconds is much longer than it needs (it will arrive much faster in the target position) but it lets us see what is happening. If we'd set the PWM channel to 2ms (to the left), and then immediately to 1ms (to the right), the servo wouldn't have time to go to the left and immediately go to the right!
+
+## Connecting a servo
+
+Servos only need three wires to work:
+
+  * Black or brown goes to ground.
+  * Red goes to the power supply (usually 5V but check your servo datasheet).
+  * Yellow/white/orange is the control wire, and is the one you will connect to the microcontroller.
+
+Be careful about the power supply! Servos need a lot of current when they are rotating, and the 5V output of a board may not be enough. So an external power supply might be a better idea. If you use a separate power supply, do make sure to connect the ground wires together otherwise the signal won't be received properly.
+
+## More information
+
+SparkFun has made an [excellent guide](https://www.sparkfun.com/servos) on servos which is well worth a read!
+
+<script type="module">
+import { setupTour } from '/tour.js';
+let code = `
+package main
+
+import "machine"
+import "time"
+
+func main() {
+	// Board specific configuration.
+	servoPin := machine.GP16
+	pwm := machine.PWM0
+
+	// Configure the timer/PWM.
+	err := pwm.Configure(machine.PWMConfig{
+		Period: 20e6, // 20ms (for standard servos)
+	})
+	if err != nil {
+		println("could not configure:", err.Error())
+		return
+	}
+
+	// Get the channel for this PWM peripheral.
+	ch, err := pwm.Channel(servoPin)
+	if err != nil {
+		println("could not obtain channel:", err.Error())
+		return
+	}
+
+	// Left position at 2000µs (2ms) "on" time.
+	println("left:  -90°")
+	pwm.Set(ch, pwm.Top()*20/200)
+	time.Sleep(time.Second * 3)
+
+	// Right position, at 1000µs (1ms) "on" time.
+	println("right: +90°")
+	pwm.Set(ch, pwm.Top()*10/200)
+	time.Sleep(time.Second * 3)
+
+	// Center position, at 1500µs (1.5ms) "on" time.
+	println("center: 0°")
+	pwm.Set(ch, pwm.Top()*15/200)
+	time.Sleep(time.Second * 3)
+}
+`;
+let servoConfig = {
+	type: 'servo',
+	humanName: 'Servo',
+	svg: 'servo-sg90.svg',
+};
+setupTour({
+	boards: {
+		'arduino-nano33': {
+			code: code.replace('machine.PWM0', 'machine.TCC0').replace('machine.GP16', 'machine.D2'),
+			parts: {
+				main: {
+					y: 15,
+				},
+				servo: {
+					config: servoConfig,
+					x: 0,
+					y: -12,
+				},
+			},
+			wires: [
+				{from: 'main.D2', to: 'servo.control'},
+			],
+		},
+		'circuitplay-bluefruit': {
+			code: code.replace('machine.GP16', 'machine.A1'),
+			parts: {
+				main: {
+					x: -25,
+				},
+				servo: {
+					config: servoConfig,
+					x: 25,
+					y: -10,
+				},
+			},
+			wires: [
+				{from: 'main.A1', to: 'servo.control'},
+			],
+		},
+		'circuitplay-express': {
+			code: code.replace('machine.PWM0', 'machine.TCC0').replace('machine.GP16', 'machine.A1'),
+			parts: {
+				main: {
+					x: -25,
+				},
+				servo: {
+					config: servoConfig,
+					x: 25,
+					y: -10,
+				},
+			},
+			wires: [
+				{from: 'main.A1', to: 'servo.control'},
+			],
+		},
+		'pico': {
+			code: code,
+			parts: {
+				main: {
+					y: 15,
+				},
+				servo: {
+					config: servoConfig,
+					x: 0,
+					y: -12,
+				},
+			},
+			wires: [
+				{from: 'main.GP16', to: 'servo.control'},
+			],
+		},
+	}});
+</script>
diff --git a/content/tour/ws2812/_index.md b/content/tour/ws2812/_index.md
new file mode 100644
index 00000000..172e7ecc
--- /dev/null
+++ b/content/tour/ws2812/_index.md
@@ -0,0 +1,6 @@
+---
+title: "WS2812/NeoPixel LEDs"
+description: "Control common addressable LEDs"
+type: "docs"
+weight: 3
+---
diff --git a/content/tour/ws2812/animating.md b/content/tour/ws2812/animating.md
new file mode 100644
index 00000000..9df5db9a
--- /dev/null
+++ b/content/tour/ws2812/animating.md
@@ -0,0 +1,176 @@
+---
+title: "Animating LEDs"
+description: How to animate LEDs using a main loop.
+weight: 2
+---
+
+Manually setting the color of each LED is nice, but of course it's much more interesting to animate them! Of course that's possible with a bit more code, see the code and demo on the right.
+
+There are many ways to code an animation, but one that works well in many cases is by using a main loop that updates the in-memory color values, sends them out to the LED strip, and sleeps for a bit. Let's go through the code:
+
+```go
+	// Configure LEDs.
+	ledPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	ws := ws2812.New(ledPin)
+	leds := make([]color.RGBA, 10)
+```
+
+This configures the LEDs as before. One difference is that we create a slice of color values in advance, without setting their initial values. But since all color components get initialized to zero, this effectively creates an all-black color slice.
+
+```go
+	red := false
+	for {
+		// ...
+	}
+```
+
+This is the main loop of the program. It's an infinite loop (much like the `loop` function on the Arduino platform) that controls the LEDs infinitely - or, more likely, until you pull the power.
+
+Note also that it initializes the `red` variable to false, which is later used to toggle the color each cycle.
+
+```go
+		// Update the in-memory LED array.
+		red = !red
+		for i := range leds {
+			red = !red
+			if red {
+				leds[i] = color.RGBA{R: 0xff}
+			} else {
+				leds[i] = color.RGBA{G: 0xff}
+			}
+		}
+```
+
+This is the first step of the loop. All values in the LED array get set to a specific color (red or green), toggling the color for each LED.
+
+```go
+		// Send the new colors to the LED strip.
+		ws.WriteColors(leds)
+```
+
+Like before, this is where the LED strip gets updated.
+
+```go
+		// Wait a bit until the next update.
+		time.Sleep(time.Second / 2)
+```
+
+This sleeps for a bit, so that the LED animation looks correct. In fact, this sleep is necessary for the correct functioning of the LED strip! Because the WS2812 protocol only knows when it has received all data when there's a short delay (up to 50µs) in the received data, we need to sleep for at least a short while.
+
+
+<script type="module">
+import { setupTour } from '/tour.js';
+let code = `
+package main
+
+import (
+	"image/color"
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/ws2812"
+)
+
+const ledPin = machine.WS2812
+
+func main() {
+	// Configure LEDs.
+	ledPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	ws := ws2812.New(ledPin)
+	leds := make([]color.RGBA, 10)
+
+	red := false
+	for {
+		// Update the in-memory LED array.
+		red = !red
+		for i := range leds {
+			red = !red
+			if red {
+				leds[i] = color.RGBA{R: 0xff}
+			} else {
+				leds[i] = color.RGBA{G: 0xff}
+			}
+		}
+
+		// Send the new colors to the LED strip.
+		ws.WriteColors(leds)
+
+		// Wait a bit until the next update.
+		time.Sleep(time.Second / 2)
+	}
+}
+`;
+let stickConfig = {
+	type: 'ws2812',
+	humanName: 'NeoPixel Stick 8',
+	svg: 'ws2812-stick-8.svg',
+	length: 8,
+};
+setupTour({
+	boards: {
+		'circuitplay-bluefruit': {},
+		'circuitplay-express': {},
+		'gopher-badge': {},
+		'arduino': {
+			code: code.replace('machine.WS2812', 'machine.D7'),
+			parts: {
+				main: {
+					x: -30,
+				},
+				stick: {
+					config: stickConfig,
+					x: 40,
+				}
+			},
+			wires: [
+				{from: 'main.D7', to: 'stick.din'},
+			],
+		},
+		'arduino-nano33': {
+			code: code.replace('machine.WS2812', 'machine.A7'),
+			parts: {
+				main: {
+					x: -30,
+				},
+				stick: {
+					config: stickConfig,
+					x: 40,
+				}
+			},
+			wires: [
+				{from: 'main.A7', to: 'stick.din'},
+			],
+		},
+		'microbit': {
+			code: code.replace('machine.WS2812', 'machine.P2'),
+			parts: {
+				main: {
+					x: -30,
+				},
+				stick: {
+					config: stickConfig,
+					x: 40,
+				}
+			},
+			wires: [
+				{from: 'main.P2', to: 'stick.din'},
+			],
+		},
+		'pico': {
+			code: code.replace('machine.WS2812', 'machine.GP16'),
+			parts: {
+				main: {
+					x: -30,
+				},
+				stick: {
+					config: stickConfig,
+					x: 40,
+				}
+			},
+			wires: [
+				{from: 'main.GP16', to: 'stick.din'},
+			],
+		},
+	},
+	code: code});
+</script>
diff --git a/content/tour/ws2812/intro.md b/content/tour/ws2812/intro.md
new file mode 100644
index 00000000..6dc34971
--- /dev/null
+++ b/content/tour/ws2812/intro.md
@@ -0,0 +1,180 @@
+---
+title: "Introduction"
+description: How to use the extremely common WS2812/NeoPixel addressable LEDs.
+weight: 1
+---
+
+You've probably seen or used these LEDs before. They're extremely common in the maker scene, for a good reason! They're cheap, widely available, and easy to use. You can control them from basically any microcontroller with just a single pin and a good power supply.
+
+On the right you can see how to control them. Some boards include WS2812 boards, so you can use those without fiddling with wires.
+
+```go
+ledPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+```
+
+Before being able to send any data, the pin needs to be set as an output. This is similar to how you'd control a single LED.
+
+```go
+ws := ws2812.New(ledPin)
+```
+
+The `ws` object is the driver for these LEDs and is later used to update the LEDs.
+
+
+```go
+leds := []color.RGBA{
+	{R: 255, G: 0, B: 0},
+	{R: 0, G: 255, B: 0},
+	{R: 0, G: 0, B: 255},
+}
+```
+
+This initializes a slice of RGB values to be sent to the LED strip. The first is red, the second green, and the third blue.
+
+```go
+ws.WriteColors(leds)
+```
+
+And here we send the LED colors to the LED strip. Easy, right?
+
+Though if you look at the output of the simulator, you can see that it is actually reversed: the first LED is blue, the second green, and the third red. What happened here?
+
+## WS2812 daisy chaining
+
+To understand why the LEDs are reversed, we need to understand a bit of how the protocol works.
+
+For the first LED, the microcontroller sends the first color in the array to the first LED. This means the first LED receives the red color. It doesn't apply the color immediately, instead it keeps the color in a buffer and waits to see whether more will be coming.
+
+But the microcontroller doesn't wait, it sends the next color (green) to the first LED. The first LED already has the color red in the buffer, so it sends the color red to the next (second) LED while receiving the green color.
+
+Now, the third color (blue) is sent. Like before, the first LED receives blue and sends the green it has in the buffer. The second LED receives green, and sends the red color to the third LED.
+
+Now the microcontroller is finished, it doesn't send anything else. In fact, the main function returns so it locks up. After a while (50µs according to the datasheet, [around 9µs in practice](https://cpldcpu.wordpress.com/2014/01/14/light_ws2812-library-v2-0-part-i-understanding-the-ws2812/)) all the LEDs in the string realize no more data is coming so they apply the color they have in their buffer.
+
+Knowing this we can do interesting things with these LEDs:
+
+  * It's possible to daisy chain many of these LED strips! They pass color data from one to the other, and so connecting multiple in a chain means you get one big LED strip. Though watch out for power consumption, this'll quickly add up!
+  * You can, if you want, control multiple LED strips in parallel. They will look the same, but it does save a pin on the microcontroller.
+  * You can update multiple chained LED strips independently! Just send them all together without any delay in between (from last to first). This can be useful for controlling chained RGB and RGBW LED strips, if you happen to have such a setup. We'll get to RGBW LED strips later.
+
+## Connecting WS2812 LEDs
+
+The simulator simplifies a lot of things. Sadly, the real world is a bit more complicated.
+
+There are extensive guides on the internet on how to connect these LEDs. [Here is one by Adafruit](https://learn.adafruit.com/adafruit-neopixel-uberguide/the-magic-of-neopixels), and [here is one by SparkFun](https://learn.sparkfun.com/tutorials/ws2812-breakout-hookup-guide/all). But in short, here are a few things you need to be aware of:
+
+  * The power wire (usually red) needs to be connected to a decent power supply. For just a few LEDs you can usually use a pin on the microcontroller board itself, this one is usually labeled "5V", "VBUS", or "VOUT". Check the pinout to be sure! For longer LED strips you will need a separate 5V power supply.
+  * The ground wire (usually white or black) needs to be connected to the microcontroller ground. If you use a separate power supply, it also needs to be connected to the ground of that power supply.
+  * The data pin (usually green) needs to be connected to the GPIO pin you are using on the board.
+  * Make sure the wires are not too long! One meter will usually work fine, but for longer wires you may need special handling.
+  * These LEDs can be very bright, especially in the dark! Many people don't run them at full brightness for this reason.
+
+
+## WS2812 vs NeoPixel vs SK6812 vs ...
+
+These are all the same type of LEDs! There are multiple companies that make these, but apart from some details these LEDs are all interchangeable. In this tour, we'll just use the name "WS2812" for the whole family.
+
+WS2812 was the original by WorldSemi (hence WS), followed by the WS2812B which made it slightly more robust. SK6812 is a very similar chip from a different company (known for making a RGBW version of the WS2812). There are many others that are usually just sold as "WS2812" even though they aren't from WorldSemi.
+
+NeoPixel is the Adafruit brand for this type of LED. They're still the same LEDs (from WorldSemi and others), just with a different name.
+
+
+<script type="module">
+import { setupTour } from '/tour.js';
+let code = `
+package main
+
+import (
+	"image/color"
+	"machine"
+
+	"tinygo.org/x/drivers/ws2812"
+)
+
+const ledPin = machine.WS2812
+
+func main() {
+	ledPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	ws := ws2812.New(ledPin)
+	leds := []color.RGBA{
+		{R: 255, G: 0, B: 0},
+		{R: 0, G: 255, B: 0},
+		{R: 0, G: 0, B: 255},
+	}
+	ws.WriteColors(leds)
+}
+`;
+let stickConfig = {
+	type: 'ws2812',
+	humanName: 'NeoPixel Stick 8',
+	svg: 'ws2812-stick-8.svg',
+	length: 8,
+};
+setupTour({
+	boards: {
+		'circuitplay-bluefruit': {},
+		'circuitplay-express': {},
+		'gopher-badge': {},
+		'arduino': {
+			code: code.replace('machine.WS2812', 'machine.D7'),
+			parts: {
+				main: {
+					x: -30,
+				},
+				stick: {
+					config: stickConfig,
+					x: 40,
+				}
+			},
+			wires: [
+				{from: 'main.D7', to: 'stick.din'},
+			],
+		},
+		'arduino-nano33': {
+			code: code.replace('machine.WS2812', 'machine.A7'),
+			parts: {
+				main: {
+					x: -30,
+				},
+				stick: {
+					config: stickConfig,
+					x: 40,
+				}
+			},
+			wires: [
+				{from: 'main.A7', to: 'stick.din'},
+			],
+		},
+		'microbit': {
+			code: code.replace('machine.WS2812', 'machine.P2'),
+			parts: {
+				main: {
+					x: -30,
+				},
+				stick: {
+					config: stickConfig,
+					x: 40,
+				}
+			},
+			wires: [
+				{from: 'main.P2', to: 'stick.din'},
+			],
+		},
+		'pico': {
+			code: code.replace('machine.WS2812', 'machine.GP16'),
+			parts: {
+				main: {
+					x: -30,
+				},
+				stick: {
+					config: stickConfig,
+					x: 40,
+				}
+			},
+			wires: [
+				{from: 'main.GP16', to: 'stick.din'},
+			],
+		},
+	},
+	code: code});
+</script>
diff --git a/content/usage/important-options.md b/content/usage/important-options.md
deleted file mode 100644
index a76d679e..00000000
--- a/content/usage/important-options.md
+++ /dev/null
@@ -1,69 +0,0 @@
----
-title: "Important Build Options"
-weight: 3
----
-
-There are a few flags to control how binaries are built:
-
-- `-o`
-Output filename, see the ``build`` command.
-
-- `-target`
-Select the target you want to use. Leave it empty to compile for the host. This switch also configures the emulator, flash tool and debugger to use so you don't have to fiddle with those options. Read [supported targets](../../microcontrollers/) for a list of supported targets. Example targets:
-
- - wasm
-WebAssembly target. Creates .wasm files that can be run in a web browser.
-
- - arduino
-Compile using the experimental AVR backend to run Go programs on an Arduino Uno.
-
- - microbit
-Compile programs for the `BBC micro:bit <https://microbit.org/>`_.
-
- - qemu
-Run on a Stellaris LM3S as emulated by QEMU.
-
-- `-port`
-Specify the serial port used for flashing. This is used for the Arduino Uno, which is flashed over a serial port. It defaults to ``/dev/ttyACM0`` as that is the default port on Linux.
-
-- `-opt`
-Which optimization level to use. Optimization levels roughly follow standard `-O` level options like ``-O2``, ``-Os``, etc. Available optimization levels:
-
- - `-opt=0`
-Disable as much optimizations as possible. There are still a few optimization passes that run to make sure the program executes correctly, but all LLVM passes that can be disabled are disabled.
-
- - `-opt=1`
-Enable only a few optimization passes. In particular, this keeps the inliner disabled. It can be useful when you want to look at the generated IR but want to avoid the noise that is common in non-optimized code.
-
- - `-opt=2`
-A good optimization level for use cases not strongly limited by code size. Provided here for completeness. It enables most optimizations and will likely result in the fastest code.
-
- - `-opt=s`
-Like `-opt=2`, but while being more careful about code size. It provides a balance between performance and code size.
-
- - `-opt=z` (default)
-Like ``-opt=s``, but more aggressive about code size. This pass also reduces the inliner threshold by a large margin. Use this pass if you care a lot about code size.
-
-- `-ocd-output`
-Print output of the on-chip debugger tool (like OpenOCD) while in a `tinygo gdb` session. This can be useful to diagnose connection problems.
-
-- `-gc`
-Use the specified memory manager:
-
- - `-gc=none`
-Do not use a memory manager at all. This will cause a link error at every place in the program that tries to allocate memory. The primary use case for this is finding such locations.
-
- - `-gc=dumb`
-Only allocate memory, never free it. This is the simplest allocator possible and uses very few resources while being very portable. Also, allocation is very fast. Larger programs will likely need a real garbage collector.
-
- - `-gc=marksweep`
-Simple conservative mark/sweep garbage collector. This collector does not yet work on all platforms. Also, the performance of the collector is highly unpredictable as any allocation may trigger a garbage collection cycle.
-
-- `-panic`
-Use the specified panic strategy. That is, what the compiled program should do when a panic occurs.
-
-  - `-panic=abort`
-    Print the panic message and abort the program. This is the default. On a desktop system this results in a call to [`abort`](https://manpages.debian.org/stretch/manpages-dev/abort.3.en.html). On WebAssembly this is implemented as the [`unreachable`](https://webassembly.github.io/spec/core/syntax/instructions.html#syntax-instr-control) instruction. On microcontrollers, it results in a hang (endless loop).
-
-  - `-panic=trap`
-    Do not print the panic message but instead of printing anything, it directly hits a trap instruction. This instruction varies by platform but it will result in the immediate termination of the program. It could either exit with `SIGILL` or cause a call to the `HardFault_Handler`. It can be used to reduce the size of the compiled program while keeping standard Go safety rules intact at the cost of debuggability.
diff --git a/content/usage/misc-options.md b/content/usage/misc-options.md
deleted file mode 100644
index 878c209c..00000000
--- a/content/usage/misc-options.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "Misc. Build Options"
-weight: 4
----
-
-- `-no-debug`
-Disable outputting debug symbols. This can be useful for WebAssembly, as there is no debugger for .wasm files yet and .wasm files are generally served directly. Avoiding debug symbols can have a big impact on generated binary size, reducing them by more than half.
-This is not necessary on microcontrollers because debugging symbols are not flashed to the microcontroller. Additionally, you will need it when you use `tinygo gdb`. In general, it is recommended to include debug symbols unless you have a good reason not to.
-Note: while there is some support for debug symbols, only line numbers have been implemented so far. That means single-stepping and stacktraces work just fine, but no variables can be inspected.
-
-- `-size`
-Print size (``none``, ``short``, or ``full``) of the output (linked) binary. Note that the calculated size includes RAM reserved for the stack.
-
-- `none` (default)
-Print nothing.
-
-- `short`
-Print size statistics, roughly like what the ``size`` binutils program would print but with useful flash and RAM columns:
-```
-code    data     bss |   flash     ram
-5780     144    2132 |    5924    2276
-```
-
-- `full`
-Try to determine per package how much space is used. Note that these calculations are merely guesses and can somethimes be way off due to various reasons like inlining:
-```
-code  rodata    data     bss |   flash     ram | package
-876        0       4       0 |     880       4 | (bootstrap)
-38         0       0       0 |      38       0 | device/arm
-0          0       0      66 |       0      66 | machine
-2994     440     124       0 |    3558     124 | main
-948      127       4       1 |    1079       5 | runtime
-4856     567     132      67 |    5555     199 | (sum)
-5780       -     144    2132 |    5924    2276 | (all)
-```
diff --git a/content/usage/subcommands.md b/content/usage/subcommands.md
deleted file mode 100644
index ac9c442b..00000000
--- a/content/usage/subcommands.md
+++ /dev/null
@@ -1,52 +0,0 @@
----
-title: "Subcommands"
-weight: 2
----
-
-TinyGo tries to be similar to the main `go` command in usage. It consists of the following main subcommands:
-
-### build
-Compile the given program. The output binary is specified using the ``-o``
-parameter. The generated file type depends on the extension:
-
-`.o`
-Create a relocatable object file. You can use this option if you don't want to use the TinyGo build system or want to do other custom things.
-
-`.ll`
-Create textual LLVM IR, after optimization. This is mainly useful for debugging.
-
-`.bc`
-Create LLVM bitcode, after optimization. This may be useful for debugging or for linking into other programs using LTO.
-
-`.hex`
-Create an [Intel HEX](https://en.wikipedia.org/wiki/Intel_HEX) file to flash it to a microcontroller.
-
-`.bin`
-Similar, but create a binary file.
-
-`.wasm`
-Compile and link a WebAssembly file.
-
-(all other)
-Compile and link the program into a regular executable. For microcontrollers, it is common to use the .elf file extension to indicate a linked ELF file is generated. For Linux, it is common to build binaries with no extension at all.
-
-### run
-Run the program, either directly on the host or in an emulated environment (depending on `-target`).
-
-### flash
-Flash the program to a microcontroller.
-
-### gdb
-Compile the program, optionally flash it to a microcontroller if it is a remote target, and drop into a GDB shell. From there you can set breakpoints, start the program with `run` or `continue` (`run` for a local program, `continue` for on-chip debugging), single-step, show a backtrace, break and resume the program with Ctrl-C/`continue`, etc. You may need to install extra tools (like `openocd` and `arm-none-eabi-gdb`) to be able to do this. Also, you may need a dedicated debugger to be able to debug certain boards if no debugger is integrated. Some boards (like the BBC micro:bit and most professional evaluation boards) have an integrated debugger.
-
-### clean
-Clean the cache directory, normally stored in `$HOME/.cache/tinygo`. This is not normally needed.
-
-### help
-Print a short summary of the available commands, plus a list of command flags.
-
-### version
-Print the version of the command and the version of the used `$GOROOT`.
-
-### env
-Print a list of environment variables that affect TinyGo (as a shell script). If one or more variable names are given as arguments, env prints the value of each on a new line.
diff --git a/content/webassembly/_index.md b/content/webassembly/_index.md
deleted file mode 100644
index 8b72768b..00000000
--- a/content/webassembly/_index.md
+++ /dev/null
@@ -1,9 +0,0 @@
----
-title: "WebAssembly (WASM)"
-chapter: true
-weight: 4
----
-
-# TinyGo and WebAssembly
-
-TinyGo can compile to WebAssembly (WASM) so you can use it to create new browser-based applications.
diff --git a/doc-gen/go.mod b/doc-gen/go.mod
index c8dc4f21..2a20ea6a 100644
--- a/doc-gen/go.mod
+++ b/doc-gen/go.mod
@@ -1,5 +1,12 @@
 module github.com/tinygo-org/tinygo-site/doc-gen
 
-go 1.11
+go 1.23.0
 
-require golang.org/x/tools v0.0.0-20201121010211-780cb80bd7fb
+toolchain go1.24.1
+
+require golang.org/x/tools v0.31.0
+
+require (
+	golang.org/x/mod v0.24.0 // indirect
+	golang.org/x/sync v0.12.0 // indirect
+)
diff --git a/doc-gen/go.sum b/doc-gen/go.sum
index c5564f97..09ebfb8a 100644
--- a/doc-gen/go.sum
+++ b/doc-gen/go.sum
@@ -1,24 +1,8 @@
-github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/mod v0.3.0 h1:RM4zey1++hCTbCVQfnWeKs9/IEsaBLA8vTkd0WVtmH4=
-golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20201121010211-780cb80bd7fb h1:z5+u0pkAUPUWd3taoTialQ2JAMo4Wo1Z3L25U4ZV9r0=
-golang.org/x/tools v0.0.0-20201121010211-780cb80bd7fb/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+golang.org/x/mod v0.24.0 h1:ZfthKaKaT4NrhGVZHO1/WDTwGES4De8KtWO0SIbNJMU=
+golang.org/x/mod v0.24.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
+golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw=
+golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/tools v0.31.0 h1:0EedkvKDbh+qistFTd0Bcwe/YLh4vHwWEkiI0toFIBU=
+golang.org/x/tools v0.31.0/go.mod h1:naFTU+Cev749tSJRXJlna0T3WxKvb1kWEx15xA4SdmQ=
diff --git a/doc-gen/main.go b/doc-gen/main.go
index 6629d89e..592f2211 100644
--- a/doc-gen/main.go
+++ b/doc-gen/main.go
@@ -4,14 +4,16 @@ import (
 	"bytes"
 	"fmt"
 	"go/ast"
-	"go/parser"
+	"go/constant"
 	"go/printer"
 	"go/token"
-	"io"
+	"go/types"
+	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
 	"strings"
 	"text/template"
 
@@ -35,6 +37,20 @@ type Type struct {
 	Funcs map[string]*ast.FuncDecl
 }
 
+type Pin struct {
+	HardwareName string
+	OtherNames   []string
+	Peripherals  map[string][]string
+}
+
+// Match formats:
+// - PA0 (AVR)
+// - PA00 (Microchip SAM series)
+// - P0_00 (nrf series),
+// - GPIO0 (esp series, rp2040)
+// - P00 (sifive)
+var pinIsHardwareName = regexp.MustCompile("^(P[A-Z][0-9]+|P[0-1]_[0-9]{2}|GPIO[0-9]+|P[0-9]{2})$")
+
 var markdownTemplateText = `
 ---
 title: {{.Target}}
@@ -82,13 +98,18 @@ title: {{.Target}}
 func main() {
 	// Get the target from the list of command line options.
 	for _, target := range os.Args[1:] {
+		path := filepath.Join("..", "content", "docs", "reference", "microcontrollers", "machine", target+".md")
+		docPath := filepath.Join("..", "content", "docs", "reference", "microcontrollers", target+".md")
+		if _, err := os.Stat(docPath); err != nil {
+			fmt.Println("Skipping:                    ", target)
+			continue
+		}
 		fmt.Println("Generating documentation for:", target)
-		path := filepath.Join("..", "content", "microcontrollers", "machine", target+".md")
-		writeTargetDoc(target, path)
+		updateDocumentation(target, path, docPath)
 	}
 }
 
-func writeTargetDoc(target, path string) {
+func updateDocumentation(target, path, docPath string) {
 	// Get the important information from the compiler.
 	cmd := exec.Command("tinygo", "info", target)
 	outBytes, err := cmd.Output()
@@ -97,7 +118,7 @@ func writeTargetDoc(target, path string) {
 		os.Exit(1)
 	}
 	var buildTags []string
-	var goos, goarch string
+	var goos, goarch, goroot string
 	for _, line := range strings.Split(string(outBytes), "\n") {
 		idx := strings.IndexByte(line, ':')
 		if idx < 0 {
@@ -112,56 +133,55 @@ func writeTargetDoc(target, path string) {
 			goos = value
 		case "GOARCH":
 			goarch = value
+		case "cached GOROOT":
+			goroot = value
 		}
 	}
-	if len(buildTags) == 0 || goos == "" || goarch == "" {
-		fmt.Fprintln(os.Stderr, "could not find all needed properties (build tags, GOOS, GOARCH)")
-		os.Exit(1)
-	}
-
-	f, err := os.Create(path)
-	if err != nil {
-		fmt.Fprintln(os.Stderr, "could not open file:", err)
+	if len(buildTags) == 0 || goos == "" || goarch == "" || goroot == "" {
+		fmt.Fprintln(os.Stderr, "could not find all needed properties (build tags, GOOS, GOARCH, GOROOT)")
 		os.Exit(1)
 	}
-	defer f.Close()
-	writeDoc(f, target, buildTags, goos, goarch)
-}
 
-func writeDoc(out io.Writer, target string, buildTags []string, goos, goarch string) {
 	// Get the list of files that would be compiled for this package.
 	pkgs, err := packages.Load(&packages.Config{
-		Mode:       packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles,
+		Mode:       packages.NeedName | packages.NeedSyntax | packages.NeedTypes | packages.NeedDeps,
 		BuildFlags: []string{"-tags=" + strings.Join(buildTags, " ")},
-		Env:        append(os.Environ(), "GOOS="+goos, "GOARCH="+goarch, "GO111MODULE=off"),
-	}, "github.com/tinygo-org/tinygo/src/machine")
+		Env:        append(os.Environ(), "GOOS="+goos, "GOARCH="+goarch, "GOROOT="+goroot, "GO111MODULE=off"),
+	}, "machine")
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	// Do some sanity checking.
-	if len(pkgs[0].Errors) != 0 {
-		for _, err := range pkgs[0].Errors {
-			fmt.Fprintln(os.Stderr, err)
+	hasError := false
+	for _, err := range pkgs[0].Errors {
+		if err.Kind == packages.TypeError {
+			// Ignore type errors, they happen sometimes because TinyGo CGo is
+			// missing.
+			continue
 		}
+		hasError = true
+		fmt.Fprintln(os.Stderr, err)
+	}
+	if hasError {
 		os.Exit(1)
 	}
-	if len(pkgs[0].CompiledGoFiles) == 0 {
-		fmt.Fprintln(os.Stderr, "no compiled Go files found for target:", target)
+	pkg := pkgs[0]
+
+	err = writeMachinePackageDoc(path, target, pkg)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "error:", err)
 		os.Exit(1)
 	}
 
-	// Parse all to-be-compiled files.
-	syntax := make([]*ast.File, len(pkgs[0].CompiledGoFiles))
-	fset := token.NewFileSet()
-	for i, fileName := range pkgs[0].CompiledGoFiles {
-		file, err := parser.ParseFile(fset, fileName, nil, parser.ParseComments)
-		if err != nil {
-			log.Fatal("failed to parse Go source file:", err)
-		}
-		syntax[i] = file
+	err = updateBoardDocumentation(docPath, pkg, buildTags)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "error:", err)
+		os.Exit(1)
 	}
+}
 
+func writeMachinePackageDoc(path, target string, pkg *packages.Package) error {
 	doc := PackageDoc{
 		Target: target,
 		Types:  make(map[string]*Type),
@@ -169,7 +189,7 @@ func writeDoc(out io.Writer, target string, buildTags []string, goos, goarch str
 	}
 
 	// Read everything except for functions.
-	for _, file := range syntax {
+	for _, file := range pkg.Syntax {
 		for _, decl := range file.Decls {
 			switch decl := decl.(type) {
 			case *ast.GenDecl:
@@ -211,7 +231,7 @@ func writeDoc(out io.Writer, target string, buildTags []string, goos, goarch str
 
 	// Read functions after types have been read, to attach functions to type
 	// documentation.
-	for _, file := range syntax {
+	for _, file := range pkg.Syntax {
 		for _, decl := range file.Decls {
 			switch decl := decl.(type) {
 			case *ast.FuncDecl:
@@ -230,9 +250,11 @@ func writeDoc(out io.Writer, target string, buildTags []string, goos, goarch str
 					case *ast.StarExpr:
 						receiverName = receiver.X.(*ast.Ident).Name
 					default:
-						log.Fatal("unknown receiver for:", decl.Name.Name)
+						return fmt.Errorf("unknown receiver for %s", decl.Name.Name)
+					}
+					if ast.IsExported(receiverName) {
+						doc.Types[receiverName].Funcs[decl.Name.Name] = decl
 					}
-					doc.Types[receiverName].Funcs[decl.Name.Name] = decl
 				}
 			}
 		}
@@ -263,19 +285,398 @@ func writeDoc(out io.Writer, target string, buildTags []string, goos, goarch str
 					Rparen: n.Rparen,
 				}
 			}
-			printer.Fprint(w, fset, node)
+			printer.Fprint(w, pkg.Fset, node)
 			text := string(w.Bytes())
 			return "```go\n" + text + "\n```\n"
 		},
 		"formatReceiver": func(receiver *ast.FieldList) string {
 			// Special case for formatting the receiver of a method.
 			w := &bytes.Buffer{}
-			printer.Fprint(w, fset, receiver.List[0].Type)
+			printer.Fprint(w, pkg.Fset, receiver.List[0].Type)
 			return string(w.Bytes())
 		},
 	}).Parse(markdownTemplateText))
-	err = tpl.Execute(out, doc)
+
+	f, err := os.Create(path)
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "error:", err)
+		return fmt.Errorf("could not open file: %w", err)
+	}
+	defer f.Close()
+
+	return tpl.Execute(f, doc)
+}
+
+func findSection(name, doc string) (start, end int, err error) {
+	start = strings.Index(doc, fmt.Sprintf("## %s\n", name))
+	if start < 0 {
+		return 0, 0, fmt.Errorf("could not find '%s' header", name)
+	}
+	endOffset := strings.Index(doc[start:], "\n## ")
+	if endOffset < 0 {
+		return 0, 0, fmt.Errorf("could not find end of '%s' header", name)
+	}
+	end = start + endOffset
+	return
+}
+
+func updateBoardDocumentation(path string, pkg *packages.Package, buildTags []string) error {
+	features := detectSupportedFeatures(pkg, buildTags)
+
+	// Read the entire Markdown file in memory.
+	docBuf, err := ioutil.ReadFile(path)
+	if err != nil {
+		return fmt.Errorf("could not read Markdown file: %w", err)
+	}
+	doc := string(docBuf)
+
+	// Find "Interfaces" section.
+	start, end, err := findSection("Interfaces", doc)
+	if err != nil {
+		return err
+	}
+
+	// Create new "Interfaces" section based on the previous section.
+	interfacesText := "## Interfaces\n\n| Interface | Hardware Supported | TinyGo Support |\n| --------- | ------------- | ----- |\n"
+	for _, line := range strings.Split(doc[start:end], "\n") {
+		if !strings.HasPrefix(line, "| ") {
+			continue
+		}
+		parts := strings.Split(line, "|")
+		if len(parts) != 5 {
+			return fmt.Errorf("expected 5 parts, got %d", len(parts))
+		}
+		feature := strings.TrimSpace(parts[1])
+		if feature == "Interface" || feature[0] == '-' {
+			// Part of the hearder.
+			continue
+		}
+		hardwareSupport := strings.TrimSpace(parts[2])
+		softwareSupport := strings.TrimSpace(parts[3])
+		if hardwareSupport != "NO" && hardwareSupport != "?" {
+			if supported, ok := features[feature]; ok {
+				if supported {
+					softwareSupport = "YES"
+				} else {
+					softwareSupport = "Not yet"
+				}
+			}
+		}
+		interfacesText += fmt.Sprintf("| %-9s | %-3s | %-3s |\n", feature, hardwareSupport, softwareSupport)
+	}
+
+	// Replace the "Interfaces" section.
+	doc = doc[:start] + interfacesText + doc[end:]
+
+	start, end, err = findSection("Pins", doc)
+	if err == nil {
+		// There is a pins section. Update it from the machine package.
+		pinsText, err := getPinsSection(pkg)
+		if err != nil {
+			return err
+		}
+
+		// Replace the "Pins" section.
+		doc = doc[:start] + pinsText + doc[end:]
+	}
+
+	// Write out the updated documentation.
+	err = ioutil.WriteFile(path+".tmp", []byte(doc), 0o666)
+	if err != nil {
+		return fmt.Errorf("could not write updated Markdown file: %w", err)
+	}
+	err = os.Rename(path+".tmp", path)
+	if err != nil {
+		return fmt.Errorf("could not rename updated Markdown file: %w", err)
+	}
+
+	return nil
+}
+
+// detectSupportedFeatures check whether a given feature is supported by the
+// chip/board based on the available types in the machine package and the build
+// tags used for the compilation.
+func detectSupportedFeatures(pkg *packages.Package, buildTags []string) map[string]bool {
+	features := map[string]bool{
+		"GPIO":      false,
+		"UART":      false,
+		"SPI":       false,
+		"I2C":       false,
+		"ADC":       false,
+		"PWM":       false,
+		"Bluetooth": false,
+		"USBDevice": false,
+	}
+
+	pinType := pkg.Types.Scope().Lookup("Pin").Type()
+	if types.NewMethodSet(pinType).Lookup(pkg.Types, "Get") != nil {
+		// Note: checking the 'Get' method because the 'Set' method is always
+		// implemented (even if it's a no-op).
+		features["GPIO"] = true
+	}
+	if pkg.Types.Scope().Lookup("UART") != nil {
+		features["UART"] = true
+	}
+	if pkg.Types.Scope().Lookup("SPI") != nil {
+		features["SPI"] = true
+	}
+	if pkg.Types.Scope().Lookup("I2C") != nil {
+		features["I2C"] = true
+	}
+	if pkg.Types.Scope().Lookup("ADC") != nil {
+		features["ADC"] = true
+	}
+	for _, tag := range buildTags {
+		if tag == "nrf51" || tag == "nrf52" || tag == "nrf52840" || tag == "nrf52833" {
+			features["Bluetooth"] = true
+		}
+	}
+	if pkg.Types.Scope().Lookup("USBDevice") != nil {
+		features["USBDevice"] = true
+	}
+
+	// Detecting PWM support is a bit more tricky.
+	// We basically iterate over all global variables and check whether they
+	// have Configure method that takes a single PWMConfig struct.
+	for _, file := range pkg.Syntax {
+		for _, decl := range file.Decls {
+			switch decl := decl.(type) {
+			case *ast.GenDecl:
+				if decl.Tok != token.VAR {
+					continue
+				}
+				for _, spec := range decl.Specs {
+					// Found a global variable.
+					spec := spec.(*ast.ValueSpec)
+					name := spec.Names[0].Name
+					if !ast.IsExported(name) {
+						continue
+					}
+					if classifyPeripheral(pkg, name) == "PWM" {
+						features["PWM"] = true
+					}
+				}
+			}
+		}
+	}
+
+	return features
+}
+
+func getPinsSection(pkg *packages.Package) (string, error) {
+	// Find board pin names
+	pinNames := make(map[string]uint64)
+	hardwarePins := make(map[string]struct{})
+	pinPeripherals := make(map[string][]string)
+	variableAssigns := make(map[string][]string)
+	var pinNamesSlice []string
+	for _, file := range pkg.Syntax {
+		for _, decl := range file.Decls {
+			switch decl := decl.(type) {
+			case *ast.GenDecl:
+				if decl.Tok == token.VAR {
+					for _, spec := range decl.Specs {
+						spec := spec.(*ast.ValueSpec)
+						if len(spec.Names) != 1 || len(spec.Values) != 1 {
+							continue
+						}
+						name := spec.Names[0]
+						value := spec.Values[0]
+						if !token.IsExported(name.Name) {
+							continue
+						}
+						if value, ok := value.(*ast.Ident); ok {
+							variableAssigns[value.Name] = append(variableAssigns[value.Name], name.Name)
+						}
+					}
+				}
+				if decl.Tok != token.CONST {
+					continue
+				}
+				for _, spec := range decl.Specs {
+					// Found a constant.
+					spec := spec.(*ast.ValueSpec)
+					name := spec.Names[0].Name
+					if !ast.IsExported(name) {
+						continue
+					}
+					obj := pkg.Types.Scope().Lookup(name)
+					if obj.Type().String() != "machine.Pin" {
+						continue
+					}
+					val, ok := constant.Uint64Val(obj.(*types.Const).Val())
+					if !ok {
+						return "", fmt.Errorf("expected pin %s with value %s to be representable by uint64", name, obj.(*types.Const).Val())
+					}
+					pinNamesSlice = append(pinNamesSlice, name)
+					pinNames[name] = val
+					if isHardwarePin(name, spec.Values) {
+						hardwarePins[name] = struct{}{}
+						comment := strings.TrimSpace(spec.Comment.Text())
+						if strings.HasPrefix(comment, "peripherals: ") {
+							pinPeripherals[name] = strings.Split(strings.TrimPrefix(comment, "peripherals: "), ", ")
+						}
+					}
+				}
+			}
+		}
+	}
+	if _, ok := pinNames["NoPin"]; !ok {
+		return "", fmt.Errorf("could not find NoPin constant")
+	}
+	var exposedPins []*Pin
+	pins := make(map[uint64]*Pin)
+	hasPeripheral := make(map[string]bool)
+	for _, name := range pinNamesSlice {
+		if name == "NoPin" || pinNames[name] == pinNames["NoPin"] {
+			continue
+		}
+		num := pinNames[name]
+		pin, ok := pins[num]
+		if !ok {
+			pin = &Pin{Peripherals: map[string][]string{}}
+			pins[num] = pin
+		}
+		if _, ok := hardwarePins[name]; ok {
+			// Hardware name
+			if pin.HardwareName != "" {
+				return "", fmt.Errorf("duplicate hardware pin name: %s and %s", pin.HardwareName, name)
+			}
+			pin.HardwareName = name
+			for _, peripheral := range pinPeripherals[name] {
+				parts := strings.SplitN(peripheral, " ", 2)
+				peripheralName := parts[0]
+				peripheralSuffix := parts[1]
+				var peripheralType string
+				peripherals := []string{peripheral}
+				if strings.HasPrefix(peripheralName, "I2C") {
+					peripheralType = "I2C"
+				} else if strings.HasPrefix(peripheralName, "sercomI2CM") {
+					peripheralType = "I2C"
+					peripherals = nil
+					for _, name := range variableAssigns[peripheralName] {
+						peripherals = append(peripherals, name+" "+peripheralSuffix)
+					}
+				} else {
+					peripheralType = classifyPeripheral(pkg, peripheralName)
+				}
+				if peripheralType == "I2C" || peripheralType == "PWM" {
+					for _, name := range peripherals {
+						pin.Peripherals[peripheralType] = append(pin.Peripherals[peripheralType], name)
+						hasPeripheral[peripheralType] = true
+					}
+				}
+			}
+		} else {
+			// Other name
+			if len(pin.OtherNames) == 0 {
+				exposedPins = append(exposedPins, pin)
+			}
+			pin.OtherNames = append(pin.OtherNames, name)
+		}
+	}
+
+	pinsText := "## Pins\n\n| Pin               | Hardware pin | Alternative names |"
+	if hasPeripheral["I2C"] {
+		pinsText += " I2C                  |"
+	}
+	if hasPeripheral["PWM"] {
+		pinsText += " PWM                  |"
+	}
+	pinsText += "\n| ----------------- | ------------ | ----------------- |"
+	for range hasPeripheral {
+		pinsText += " -------------------- |"
+	}
+	pinsText += "\n"
+	for _, pin := range exposedPins {
+		if pin.HardwareName == "" {
+			return "", fmt.Errorf("could not find hardware pin name for %s", pin.OtherNames[0])
+		}
+		alternativeNames := make([]string, 0, len(pin.OtherNames)-1)
+		for _, name := range pin.OtherNames[1:] {
+			alternativeNames = append(alternativeNames, "`"+name+"`")
+		}
+		pinsText += fmt.Sprintf("| %-17s | %-12s | %-17s |", "`"+pin.OtherNames[0]+"`", "`"+pin.HardwareName+"`", strings.Join(alternativeNames, ", "))
+		for _, peripheralType := range []string{"I2C", "PWM"} {
+			if !hasPeripheral[peripheralType] {
+				continue
+			}
+			var peripherals []string
+			for _, peripheral := range pin.Peripherals[peripheralType] {
+				parts := strings.SplitN(peripheral, " ", 2)
+				s := "`" + parts[0] + "` (" + parts[1] + ")"
+				s = strings.ReplaceAll(s, " ", "\u00a0") // use non-breaking space
+				peripherals = append(peripherals, s)
+			}
+			pinsText += fmt.Sprintf(" %-20s |", strings.Join(peripherals, ", "))
+		}
+		pinsText += "\n"
+	}
+
+	return pinsText, nil
+}
+
+// Return whether this pin looks like a hardware pin name. A hardware pin
+// constant is a constant like PB02 on the Arduino: a constant defined by the
+// chip, and not the board (which would be pin 13, D13, or the LED pin).
+func isHardwarePin(name string, values []ast.Expr) bool {
+	if !pinIsHardwareName.MatchString(name) {
+		return false
+	}
+	if len(values) == 0 {
+		// Pin constant is probably part of a constant like this:
+		//   const (
+		//     GPIO0 Pin = iota
+		//     GPIO1
+		//     GPIO2
+		//     // etc
+		//   )
+		return true
+	}
+	switch value := values[0].(type) {
+	case *ast.BasicLit:
+		// For example:
+		//   const GPIO5 Pin = 5
+		return true
+	case *ast.BinaryExpr:
+		// For example:
+		//   const PB02 = portB + 2
+		return true
+	case *ast.Ident:
+		if value.Name == "iota" {
+			// Pins are initialized using the special identifier "iota".
+			return true
+		}
+		// Doesn't look like a hardware pin, could be something like:
+		//   const D13 = PB5
+		return false
+	default:
+		return false
+	}
+}
+
+// Return the peripheral type for a given peripheral name, by looking at the
+// type of the global.
+func classifyPeripheral(pkg *packages.Package, name string) string {
+	global := pkg.Types.Scope().Lookup(name)
+	if global == nil {
+		// The peripheral is not available.
+		// This sometimes happen when the pins are defined for a chip family but
+		// some chips don't have all the peripherals.
+		return ""
+	}
+
+	// Check for Configure method. Most peripherals have one.
+	configureMethod := types.NewMethodSet(global.Type()).Lookup(pkg.Types, "Configure")
+	if configureMethod == nil {
+		return ""
+	}
+
+	// Check whether it has just one parameter and this parameter is of type
+	// PWMConfig.
+	params := configureMethod.Type().(*types.Signature).Params()
+	if params.Len() == 1 && params.At(0).Type() == pkg.Types.Scope().Lookup("PWMConfig").Type() {
+		return "PWM"
 	}
+	// Some other kind of peripheral.
+	return ""
 }
diff --git a/go.mod b/go.mod
new file mode 100644
index 00000000..06e2e431
--- /dev/null
+++ b/go.mod
@@ -0,0 +1,5 @@
+module github.com/tinygo-org/tinygo-site
+
+go 1.22
+
+require github.com/google/docsy v0.11.0 // indirect
diff --git a/go.sum b/go.sum
new file mode 100644
index 00000000..558b7c83
--- /dev/null
+++ b/go.sum
@@ -0,0 +1,4 @@
+github.com/FortAwesome/Font-Awesome v0.0.0-20240716171331-37eff7fa00de/go.mod h1:IUgezN/MFpCDIlFezw3L8j83oeiIuYoj28Miwr/KUYo=
+github.com/google/docsy v0.11.0 h1:QnV40cc28QwS++kP9qINtrIv4hlASruhC/K3FqkHAmM=
+github.com/google/docsy v0.11.0/go.mod h1:hGGW0OjNuG5ZbH5JRtALY3yvN8ybbEP/v2iaK4bwOUI=
+github.com/twbs/bootstrap v5.3.3+incompatible/go.mod h1:fZTSrkpSf0/HkL0IIJzvVspTt1r9zuf7XlZau8kpcY0=
diff --git a/hugo.toml b/hugo.toml
new file mode 100644
index 00000000..c39a0bab
--- /dev/null
+++ b/hugo.toml
@@ -0,0 +1,105 @@
+baseURL = "https://tinygo.org/"
+title = "TinyGo"
+languageCode = "en"
+
+theme = "github.com/google/docsy"
+
+enableGitInfo = true
+
+## Configuration for BlackFriday markdown parser: https://github.com/russross/blackfriday
+[blackfriday]
+plainIDAnchors = true
+hrefTargetBlank = true
+angledQuotes = false
+latexDashes = true
+
+# Image processing configuration.
+[imaging]
+resampleFilter = "CatmullRom"
+quality = 75
+anchor = "smart"
+
+[markup.highlight]
+noClasses = false
+
+[markup.goldmark.renderer]
+unsafe = true
+
+# Everything below this are Site Params
+[params]
+copyright = "The TinyGo Authors"
+description = "A Go compiler for small places"
+
+# Google Custom Search Engine ID. Remove or comment out to disable search.
+gcs_engine_id = "feba5f0a3db52897d"
+
+# Enable Algolia DocSearch
+# algolia_docsearch = true
+
+# Repository configuration (URLs for in-page links to opening issues and suggesting changes)
+github_repo = "https://github.com/tinygo-org/tinygo-site"
+# An optional link to a related project repo. For example, the sibling repository where your product code lives.
+github_project_repo = "https://github.com/tinygo-org/tinygo"
+github_branch= "release"
+
+
+# User interface configuration
+[params.ui]
+# Enable to show the side bar menu in its compact state.
+sidebar_menu_compact = true
+#  Set to true to disable breadcrumb navigation.
+breadcrumb_disable = false
+#  Set to true to hide the sidebar search box (the top nav search box will still be displayed if search is enabled)
+sidebar_search_disable = true
+#  Set to false if you don't want to display a logo (/assets/icons/logo.svg) in the top nav bar
+navbar_logo = true
+# Set the maximum number of menus to be displayed in the sidebar
+sidebar_menu_truncate = 1000
+# Show a menu to the left of the search menu to toggle light/dark mode (or set it to auto).
+showLightDarkModeMenu = true
+
+[params.links]
+# End user relevant links. These will show up on left side of footer and in the community page if you have one.
+[[params.links.user]]
+	name ="Mastodon"
+	url = "https://mastodon.social/@TinyGo"
+	icon = "fab fa-mastodon"
+		desc = "Follow us on Mastodon to get the latest news!"
+[[params.links.user]]
+	name ="Bluesky"
+	url = "https://bsky.app/profile/tinygo.org"
+	icon = "fab fa-bluesky"
+		desc = "You can also follow us on Bluesky"
+[[params.links.user]]
+	name ="Go Pkg Docs"
+	url = "https://pkg.go.dev/github.com/tinygo-org/tinygo?tab=doc"
+	icon = "fa fa-book"
+        desc = "Package Documentation"
+# Developer relevant links. These will show up on right side of footer and in the community page if you have one.
+[[params.links.developer]]
+	name = "GitHub"
+	url = "https://github.com/tinygo-org/tinygo"
+	icon = "fab fa-github"
+        desc = "Development takes place here!"
+[[params.links.developer]]
+	name = "Slack"
+	url = "https://gophers.slack.com/messages/CDJD3SUP6/"
+	icon = "fab fa-slack"
+        desc = "Chat with other project developers"
+
+[params.mermaid]
+enable = true
+
+[params.path_base_for_github_subdir]
+# change content/<lang>/... to content/...
+from = "content/(.*?)/(.*?)"
+to = "content/$2"
+
+# Add some extra headers to the development server.
+# This is only relevant with `hugo serve`.
+[server]
+[[server.headers]]
+    for = '/**'
+    [server.headers.values]
+      Cross-Origin-Opener-Policy = "same-origin"
+      Cross-Origin-Embedder-Policy = "require-corp"
diff --git a/imports/Makefile b/imports/Makefile
index 4f6b5103..6131e405 100644
--- a/imports/Makefile
+++ b/imports/Makefile
@@ -1,3 +1,3 @@
 
 all:
-	go run . > ../content/lang-support/stdlib.md
+	go run . > ../content/docs/reference/lang-support/stdlib.md
diff --git a/imports/go.mod b/imports/go.mod
new file mode 100644
index 00000000..5e336938
--- /dev/null
+++ b/imports/go.mod
@@ -0,0 +1,3 @@
+module github.com/tinygo-org/tinygo-site/imports
+
+go 1.16
diff --git a/imports/main.go b/imports/main.go
index 4f0eb0d6..455d9117 100644
--- a/imports/main.go
+++ b/imports/main.go
@@ -2,18 +2,23 @@ package main
 
 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"io/ioutil"
 	"os"
 	"os/exec"
+	"path/filepath"
 	"runtime"
 	"strings"
 	"text/template"
 )
 
+const (
+	testGOOS   = "linux"
+	testGOARCH = "amd64"
+)
+
 // The environment to pass to `go` commands when they are invoked.
-var commandEnv = []string{"GOPATH=/does-not-exist", "GOOS=js", "GOARCH=wasm"}
+var commandEnv = []string{"GOPATH=/does-not-exist", "GO111MODULE=off", "GOOS=" + testGOOS, "GOARCH=" + testGOARCH}
 
 var markdownTemplate = template.Must(template.New("markdown").Parse(`
 ---
@@ -24,18 +29,24 @@ The following table shows all Go standard library packages and whether they can
 
 Note that the fact they can be imported, does not mean that all functions and types in the program can be used. For example, sometimes using some functions or types of the package will still trigger compiler errors.
 
-Package | Importable
---- | --- |{{ range .}}
-{{.Path}} | {{if .CanBeCompiled}} <span style="color: green">✔</span> yes {{else}} [<span style="color: red">✗</span> no](#{{.Link}}) {{end}} | {{ end }}
+Test results are for {{.goos}}/{{.goarch}}.
+
+Package | Importable | Passes tests
+--- | --- | --- |{{ range .pkgs}}
+{{.Path}} | {{if .CanBeCompiled}} <span style="color: green">✔</span> yes {{else}} [<span style="color: red">✗</span> no](#{{.Link}}) {{end}} | {{if .PassesTests}} <span style="color: green">✔</span> yes {{else if .CanBeCompiled}} [<span style="color: red">✗</span> no](#{{.Link}}) {{else}} <span style="color: gray">✗</span> no {{end}} | {{ end }}
 
-{{range .}}
-{{if not .CanBeCompiled}}
+{{range .pkgs}}
+{{if not .PassesTests }}
 ## {{.Path}}
 
 {{if .Output}}
+{{if .CanBeCompiled}}
+The compiler gave the following error when running the tests for this package:
+{{else}}
 The compiler gave the following error when this package was imported:
+{{end}}
 
-<pre>{{.Output}}</pre>
+{{.IndentedOutput}}
 {{else if .Imports}}
 This package cannot be imported because the following dependencies cannot be compiled:
 {{range .Imports}}{{if not .CanBeCompiled}}
@@ -52,6 +63,8 @@ type Package struct {
 	Imports       []*Package
 	Output        string
 	CanBeCompiled bool
+	PassesTests   bool
+	Compiling     bool
 }
 
 func (p *Package) AllImportsCanCompile() bool {
@@ -63,19 +76,45 @@ func (p *Package) AllImportsCanCompile() bool {
 	return true
 }
 
-// Link returns the link name to a header with the path as title. Hugo replaces
-// slashes with dashes so we emulate that behavior.
+// Link returns the link name to a header with the path as title. Hugo/Docsy removes
+// slashes so we emulate that behavior.
 func (p *Package) Link() string {
-	return strings.Replace(p.Path, "/", "-", -1)
+	return strings.Replace(p.Path, "/", "", -1)
+}
+
+// IndentedOutput returns the Output variable but indented by 4 characters, so
+// that it is valid Markdown raw output.
+func (p *Package) IndentedOutput() string {
+	// Remove last newline.
+	output := strings.TrimSpace(p.Output)
+	// Add indentation for all lines (except the last of course).
+	output = "    " + strings.ReplaceAll(output, "\n", "\n    ")
+	// Add last newline again.
+	output += "\n"
+
+	return output
+}
+
+// testResult is returned by runTest. It's necessary to communicate the test
+// result back over a channel from a separate test runner goroutine.
+type testResult struct {
+	pkg            *Package
+	compiles       bool
+	compilerOutput string
+	passesTest     bool
+	testOutput     string
 }
 
 func checkPackages(goroot string) error {
 	fmt.Fprintln(os.Stderr, "gathering a list of packages...")
 
+	baseDir := filepath.Join(goroot, "src")
+
 	// Get a list of all standard library packages.
 	pkgsList := new(bytes.Buffer)
-	cmd := exec.Command("go", "list", "all")
+	cmd := exec.Command("go", "list", "std")
 	cmd.Env = append(os.Environ(), commandEnv...)
+	cmd.Dir = baseDir
 	cmd.Stdout = pkgsList
 	if err := cmd.Run(); err != nil {
 		return err
@@ -104,6 +143,7 @@ func checkPackages(goroot string) error {
 	for _, pkg := range pkgs {
 		cmd := exec.Command("go", "list", "-f", `{{ join .Imports "\n" }}`, pkg.Path)
 		buf := new(bytes.Buffer)
+		cmd.Dir = baseDir
 		cmd.Env = append(os.Environ(), commandEnv...)
 		cmd.Stdout = buf
 		err := cmd.Run()
@@ -121,50 +161,142 @@ func checkPackages(goroot string) error {
 		}
 	}
 
+	testInput := make(chan *Package, 1)
+	testOutput := make(chan testResult)
+	for i := runtime.NumCPU(); i != 0; i-- {
+		go func() {
+			for pkg := range testInput {
+				testOutput <- pkg.runTest()
+			}
+		}()
+	}
+
+	// Keep track how many tests are in flight, reaching zero means all tests
+	// have been run.
+	var testsInFlights int
+
 	// Try to compile each package of which all imports can be compiled.
-	hasProgress := true
-	for hasProgress {
-		// Continue looping until no progress can be made. At that point, all
-		// packages have been checked.
-		hasProgress = false
-		for _, pkg := range pkgs {
-			if pkg.CanBeCompiled || pkg.Output != "" || !pkg.AllImportsCanCompile() {
-				// Already tested or one of the dependencies failed.
-				continue
+	for {
+		// Fill pipeline of packages, as far as possible (possibly zero at the
+		// end).
+		for {
+			inputPkg := nextPackageToTest(pkgs)
+			if inputPkg == nil {
+				// All packages have been tested.
+				break
 			}
 
-			hasProgress = true
-
-			fmt.Fprintf(os.Stderr, "%-30s", pkg.Path)
-			temporaryGoFile := "/tmp/tinygo-test.go"
-			ioutil.WriteFile(temporaryGoFile, []byte(fmt.Sprintf("package main\nimport _ \"%s\"\nfunc main(){}\n", pkg.Path)), 0600)
-
-			cmd := exec.Command("tinygo", "build", "-o", "/tmp/tinygo-test-build.wasm", temporaryGoFile)
-			buf := new(bytes.Buffer)
-			cmd.Stdout = buf
-			cmd.Stderr = buf
-			if cmd.Run() != nil {
-				// There was an error importing this package.
-				fmt.Fprintf(os.Stderr, "fail\n")
-				msg := string(buf.Bytes())
-				if len(msg) == 0 {
-					return errors.New("tinygo exited with error but without any output!")
-				}
-				lines := strings.Split(msg, "\n")
-				if len(lines) > 15 {
-					msg = strings.Join(lines[:15], "\n") + "\n[...more lines following...]"
-				}
-				pkg.Output = msg
-			} else {
-				// This package could be compiled!
-				fmt.Fprintf(os.Stderr, "ok\n")
-				pkg.CanBeCompiled = true
+			success := false
+			select {
+			case testInput <- inputPkg:
+				inputPkg.Compiling = true
+				success = true
+				testsInFlights++
+			default:
+			}
+			if !success {
+				break
+			}
+		}
+
+		if testsInFlights == 0 {
+			break
+		}
+
+		// Receive one result and process it.
+		result := <-testOutput
+		result.pkg.Compiling = false
+		testsInFlights--
+		if !result.compiles {
+			// There was an error importing this package.
+			fmt.Fprintf(os.Stderr, "%-30s does not compile\n", result.pkg.Path)
+			msg := result.compilerOutput
+			if len(msg) == 0 {
+				msg = "[...no output...]" // should not happen
+			}
+			lines := strings.Split(msg, "\n")
+			if len(lines) > 15 {
+				msg = strings.Join(lines[:15], "\n") + "\n[...more lines following...]"
 			}
+			result.pkg.Output = msg
+		} else if !result.passesTest {
+			// There was an error running the tests for this package.
+			fmt.Fprintf(os.Stderr, "%-30s fails tests\n", result.pkg.Path)
+			msg := result.testOutput
+			if len(msg) == 0 {
+				msg = "[...no test output...]" // should definitely not happen
+			}
+			lines := strings.Split(msg, "\n")
+			if len(lines) > 15 {
+				msg = strings.Join(lines[:15], "\n") + "\n[...more lines following...]"
+			}
+			result.pkg.Output = msg
+			result.pkg.CanBeCompiled = true
+		} else {
+			// This package passes all tests!
+			fmt.Fprintf(os.Stderr, "%-30s ok\n", result.pkg.Path)
+			result.pkg.CanBeCompiled = true
+			result.pkg.PassesTests = true
 		}
 	}
 
 	// Print the output to stdout.
-	return markdownTemplate.Execute(os.Stdout, pkgMap)
+	return markdownTemplate.Execute(os.Stdout, map[string]interface{}{
+		"pkgs":   pkgMap,
+		"goos":   testGOOS,
+		"goarch": testGOARCH,
+	})
+}
+
+func (pkg *Package) runTest() (result testResult) {
+	result.pkg = pkg
+
+	// Prepare test files.
+	dir, err := ioutil.TempDir("", "tinygo-test-*")
+	if err != nil {
+		panic("could not create temporary directory: " + err.Error())
+	}
+	defer os.RemoveAll(dir)
+	temporaryGoFile := filepath.Join(dir, "main.go")
+	ioutil.WriteFile(temporaryGoFile, []byte(fmt.Sprintf("package main\nimport _ \"%s\"\nfunc main(){}\n", pkg.Path)), 0600)
+	temporaryExecutableFile := filepath.Join(dir, "main")
+
+	// Run the compile test.
+	cmd := exec.Command("tinygo", "build", "-o", temporaryExecutableFile, temporaryGoFile)
+	cmd.Env = append(cmd.Environ(), "GOOS="+testGOOS, "GOARCH="+testGOARCH)
+	buf := new(bytes.Buffer)
+	cmd.Stdout = buf
+	cmd.Stderr = buf
+	result.compiles = cmd.Run() == nil
+	result.compilerOutput = string(buf.Bytes())
+
+	// Run the actual test.
+	if result.compiles {
+		cmd := exec.Command("tinygo", "test", pkg.Path)
+		cmd.Env = append(cmd.Environ(), "GOOS="+testGOOS, "GOARCH="+testGOARCH)
+		buf := new(bytes.Buffer)
+		cmd.Stdout = buf
+		cmd.Stderr = buf
+		result.passesTest = cmd.Run() == nil
+		result.testOutput = string(buf.Bytes())
+	}
+
+	return
+}
+
+// nextPackageToTest returns the next package to test, or nil if there is no
+// available package to test.
+// While there are tests in flight, this function might return nil even though
+// there are packages available for testing.
+func nextPackageToTest(pkgs []*Package) *Package {
+	for _, pkg := range pkgs {
+		if pkg.CanBeCompiled || pkg.Compiling || pkg.Output != "" || !pkg.AllImportsCanCompile() {
+			// Already tested or one of the dependencies failed.
+			continue
+		}
+		return pkg
+	}
+	return nil
 }
 
 func shouldTestPackage(path string) bool {
@@ -172,6 +304,11 @@ func shouldTestPackage(path string) bool {
 		return false
 	}
 
+	if path == "C" {
+		// Skip CGo pseudo-package.
+		return false
+	}
+
 	if path == "runtime" || strings.HasPrefix(path, "runtime/") {
 		// Compiler-specific package.
 		return false
diff --git a/layouts/partials/hooks/body-end.html b/layouts/partials/hooks/body-end.html
new file mode 100644
index 00000000..3b4a7ec8
--- /dev/null
+++ b/layouts/partials/hooks/body-end.html
@@ -0,0 +1,8 @@
+<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/docsearch.js@2/dist/cdn/docsearch.min.js"></script>
+<script type="text/javascript"> docsearch({
+    apiKey: '42f398a5126d862b7112ee3ba7fddfb2',
+    indexName: 'tinygo',
+    inputSelector: '.td-search-input',
+    debug: false // Set debug to true if you want to inspect the dropdown
+});
+</script>
diff --git a/layouts/partials/hooks/head-end.html b/layouts/partials/hooks/head-end.html
new file mode 100644
index 00000000..bc6a1cdb
--- /dev/null
+++ b/layouts/partials/hooks/head-end.html
@@ -0,0 +1 @@
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/docsearch.js@2/dist/cdn/docsearch.min.css" />
diff --git a/layouts/partials/logo.html b/layouts/partials/logo.html
deleted file mode 100644
index cb2e150d..00000000
--- a/layouts/partials/logo.html
+++ /dev/null
@@ -1,3 +0,0 @@
-<html>
-<a href="https://tinygo.org"><img src="https://tinygo.org/images/tinygo-logo.png"><h1 style="color:white; margin:0;">TinyGo</h1><h4 style="color:white; margin:0;">Go Compiler For Small Places</h4></a>
-</html>
diff --git a/layouts/partials/menu-footer.html b/layouts/partials/menu-footer.html
deleted file mode 100644
index ff631eb1..00000000
--- a/layouts/partials/menu-footer.html
+++ /dev/null
@@ -1,9 +0,0 @@
-<center style="margin-top: -50px">Please give TinyGo a star!
-    <p></p>
-    <a class="github-button" href="https://github.com/tinygo-org/tinygo" data-icon="octicon-star" data-show-count="true" aria-label="Star TinyGo on GitHub">Star</a>
-    <a class="github-button" href="https://github.com/tinygo-org/tinygo/fork" data-icon="octicon-repo-forked" data-show-count="true" aria-label="Fork TinyGo on GitHub">Fork</a>
-    <p></p>
-    <p>Site built with <a href="http://gohugo.io/">Hugo</a></p>
-</center>
-<!-- Place this tag in your head or just before your close body tag. -->
-<script async defer src="https://buttons.github.io/buttons.js"></script>
\ No newline at end of file
diff --git a/layouts/tour/baseof.html b/layouts/tour/baseof.html
new file mode 100644
index 00000000..d6e3398a
--- /dev/null
+++ b/layouts/tour/baseof.html
@@ -0,0 +1,56 @@
+<!doctype html>
+<html itemscope itemtype="http://schema.org/WebPage"
+    {{- with .Site.Language.LanguageDirection }} dir="{{ . }}" {{- end -}}
+    {{ with .Site.Language.Lang }} lang="{{ . }}" {{- end }} {{/**/ -}}
+    class="no-js">
+  <head>
+    {{ partial "head.html" . }}
+    <link rel="stylesheet" href="/playground/simulator.css">
+    <link rel="stylesheet" href="/playground/simulator-bootstrap.css">
+    <link rel="modulepreload" href="/playground/resources/editor.bundle.min.js"/>
+  </head>
+  <body class="td-{{ .Kind }}{{ with .Page.Params.body_class }} {{ . }}{{ end }}">
+    <header>
+      {{ partial "navbar.html" . }}
+    </header>
+    <div class="container-fluid td-outer">
+      <div class="td-main">
+        <div class="row flex-xl-nowrap">
+          <aside class="col-12 col-md-3 col-xl-2 td-sidebar d-print-none">
+            {{ partial "sidebar.html" . }}
+          </aside>
+          <main class="col-12 col-md-9 col-xl-10 ps-md-5" role="main">
+            <div class="row">
+              <div class="col-12 col-xl-6">
+                {{ partial "version-banner.html" . }}
+                {{ if not .Site.Params.ui.breadcrumb_disable }}{{ partial "breadcrumb.html" . }}{{ end }}
+                {{ block "main" . }}{{ end }}
+              </div>
+              <div class="col-12 col-xl-6">
+                <div class="mb-3">
+                  <div class="playground-editor" tabindex="-1"></div>
+                </div>
+                <div class="row justify-content-end">
+                  <div class="col col-auto">
+                    <div id="board" class="btn-group mb-3">
+                      <button type="button" class="btn btn-primary dropdown-toggle" data-bs-toggle="dropdown" aria-haspopup="true" aria-expanded="false" title="Select a developer board">...</button>
+                      <div class="dropdown-menu">
+                      </div>
+                    </div>
+                    <button class="btn btn-secondary mb-3 playground-btn-reset" disabled title="Restore code and simulator to the beginning state">Reset</button>
+                    <button class="btn btn-secondary mb-3 playground-btn-flash" disabled title="Download firmware image to flash to a board">Flash</button>
+                  </div>
+                </div>
+                <div class="simulator mb-3">
+                  {{ readFile "/simulator/simulator.md" | safeHTML }}
+                </div>
+              </div>
+            </div>
+          </main>
+        </div>
+      </div>
+      {{ partial "footer.html" . }}
+    </div>
+    {{ partial "scripts.html" . }}
+  </body>
+</html>
diff --git a/layouts/tour/single.html b/layouts/tour/single.html
new file mode 100644
index 00000000..49bb662a
--- /dev/null
+++ b/layouts/tour/single.html
@@ -0,0 +1,3 @@
+{{ define "main" }}
+{{ .Render "content" }}
+{{ end }}
diff --git a/netlify.toml b/netlify.toml
index d650a0f1..52e3dd6d 100644
--- a/netlify.toml
+++ b/netlify.toml
@@ -1,5 +1,33 @@
 # netlify.toml
 
+# Default build settings
+[build]
+  command = "hugo"
+
+# "production" environment specific build settings
+[build.environment]
+  NODE_VERSION = "20.16.0" # LTS version
+  HUGO_VERSION = "0.133.1"
+  GO_VERSION = "1.22.x" # any reasonably recent version
+
+# "production" environment specific build settings
+[context.release.environment]
+  HUGO_ENV = "production"
+
+# Required for the playground (it needs SharedArrayBuffer).
+[[headers]]
+  for = "/*"
+  [headers.values]
+    Cross-Origin-Opener-Policy = "same-origin"
+    Cross-Origin-Embedder-Policy = "require-corp"
+
+# Internal redirect for playground share URLs.
+[[redirects]]
+  force = false
+  from = "/play/s/*"
+  to = "/play/"
+  status = 200
+
 [[redirects]]
   from = "/bluetooth"
   to = "https://github.com/tinygo-org/bluetooth#go-bluetooth"
@@ -9,3 +37,98 @@
   from = "https://bluetooth.tinygo.org"
   to = "https://github.com/tinygo-org/bluetooth#go-bluetooth"
   status = 301
+
+[[redirects]]
+  from = "/compiler-internals/*"
+  to = "/docs/concepts/compiler-internals/:splat"
+  status = 301
+
+[[redirects]]
+  from = "/faq/*"
+  to = "/docs/concepts/faq/:splat"
+  status = 301
+
+[[redirects]]
+  from = "/microcontrollers"
+  to = "/docs/reference/microcontrollers"
+  status = 301
+
+[[redirects]]
+  from = "/microcontrollers/arduino-nano33-iot"
+  to = "/docs/reference/microcontrollers/arduino-nano33"
+  status = 301
+
+[[redirects]]
+  from = "/microcontrollers/arduino-uno"
+  to = "/docs/reference/microcontrollers/arduino"
+  status = 301
+
+[[redirects]]
+  from = "/microcontrollers/circuit-playground-bluefruit"
+  to = "/docs/reference/microcontrollers/circuitplay-bluefruit"
+  status = 301
+
+[[redirects]]
+  from = "/microcontrollers/circuit-playground-express"
+  to = "/docs/reference/microcontrollers/circuitplay-express"
+  status = 301
+
+[[redirects]]
+  from = "/microcontrollers/esp8266-d1mini"
+  to = "/docs/reference/microcontrollers/d1mini"
+  status = 301
+
+[[redirects]]
+  from = "/microcontrollers/dragino-lgt92"
+  to = "/docs/reference/microcontrollers/lgt-92"
+  status = 301
+
+[[redirects]]
+  from = "/microcontrollers/bbc-microbit"
+  to = "/docs/reference/microcontrollers/microbit"
+  status = 301
+
+[[redirects]]
+  from = "/microcontrollers/nintendo-switch"
+  to = "/docs/reference/microcontrollers/nintendoswitch"
+  status = 301
+
+[[redirects]]
+  from = "/microcontrollers/esp8266-nodemcu"
+  to = "/docs/reference/microcontrollers/nodemcu"
+  status = 301
+
+[[redirects]]
+  from = "/microcontrollers/stm32-nucleo-f722ze"
+  to = "/docs/reference/microcontrollers/nucleo-f722ze"
+  status = 301
+
+[[redirects]]
+  from = "/microcontrollers/pinetime"
+  to = "/docs/reference/microcontrollers/pinetime-devkit0"
+  status = 301
+
+[[redirects]]
+  from = "/microcontrollers/stm32f4discovery"
+  to = "/docs/reference/microcontrollers/stm32f4disco"
+  status = 301
+
+[[redirects]]
+  from = "/microcontrollers/stm32-nucleo-l552ze"
+  to = "/docs/reference/microcontrollers/stm32nucleol552ze"
+  status = 301
+
+[[redirects]]
+  from = "/microcontrollers/x9-pro"
+  to = "/docs/reference/microcontrollers/x9pro"
+  status = 301
+
+[[redirects]]
+  from = "/microcontrollers/*"
+  to = "/docs/reference/microcontrollers/:splat"
+  status = 301
+
+[[redirects]]
+  from = "/lang-support/*"
+  to = "/docs/reference/lang-support/:splat"
+  status = 301
diff --git a/package-lock.json b/package-lock.json
new file mode 100644
index 00000000..0b1f1a63
--- /dev/null
+++ b/package-lock.json
@@ -0,0 +1,1048 @@
+{
+  "name": "tinygo-site",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "tinygo-site",
+      "version": "1.0.0",
+      "license": "ISC",
+      "devDependencies": {
+        "autoprefixer": "^10.4.19",
+        "postcss": "^8.4.40",
+        "postcss-cli": "^11.0.0"
+      }
+    },
+    "node_modules/@nodelib/fs.scandir": {
+      "version": "2.1.5",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
+      "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
+      "dev": true,
+      "dependencies": {
+        "@nodelib/fs.stat": "2.0.5",
+        "run-parallel": "^1.1.9"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/@nodelib/fs.stat": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
+      "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
+      "dev": true,
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/@nodelib/fs.walk": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
+      "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
+      "dev": true,
+      "dependencies": {
+        "@nodelib/fs.scandir": "2.1.5",
+        "fastq": "^1.6.0"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/@sindresorhus/merge-streams": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/@sindresorhus/merge-streams/-/merge-streams-2.3.0.tgz",
+      "integrity": "sha512-LtoMMhxAlorcGhmFYI+LhPgbPZCkgP6ra1YL604EeF6U98pLlQ3iWIGMdWSC+vWmPBWBNgmDBAhnAobLROJmwg==",
+      "dev": true,
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/anymatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.2.tgz",
+      "integrity": "sha512-P43ePfOAIupkguHUycrc4qJ9kz8ZiuOUijaETwX7THt0Y/GNK7v0aa8rY816xWjZ7rJdA5XdMcpVFTKMq+RvWg==",
+      "dev": true,
+      "dependencies": {
+        "normalize-path": "^3.0.0",
+        "picomatch": "^2.0.4"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/autoprefixer": {
+      "version": "10.4.19",
+      "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.19.tgz",
+      "integrity": "sha512-BaENR2+zBZ8xXhM4pUaKUxlVdxZ0EZhjvbopwnXmxRUfqDmwSpC2lAi/QXvx7NRdPCo1WKEcEF6mV64si1z4Ew==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/autoprefixer"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "dependencies": {
+        "browserslist": "^4.23.0",
+        "caniuse-lite": "^1.0.30001599",
+        "fraction.js": "^4.3.7",
+        "normalize-range": "^0.1.2",
+        "picocolors": "^1.0.0",
+        "postcss-value-parser": "^4.2.0"
+      },
+      "bin": {
+        "autoprefixer": "bin/autoprefixer"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      },
+      "peerDependencies": {
+        "postcss": "^8.1.0"
+      }
+    },
+    "node_modules/binary-extensions": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz",
+      "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/braces": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+      "dev": true,
+      "dependencies": {
+        "fill-range": "^7.1.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/browserslist": {
+      "version": "4.23.2",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.23.2.tgz",
+      "integrity": "sha512-qkqSyistMYdxAcw+CzbZwlBy8AGmS/eEWs+sEV5TnLRGDOL+C5M2EnH6tlZyg0YoAxGJAFKh61En9BR941GnHA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "dependencies": {
+        "caniuse-lite": "^1.0.30001640",
+        "electron-to-chromium": "^1.4.820",
+        "node-releases": "^2.0.14",
+        "update-browserslist-db": "^1.1.0"
+      },
+      "bin": {
+        "browserslist": "cli.js"
+      },
+      "engines": {
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      }
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001643",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001643.tgz",
+      "integrity": "sha512-ERgWGNleEilSrHM6iUz/zJNSQTP8Mr21wDWpdgvRwcTXGAq6jMtOUPP4dqFPTdKqZ2wKTdtB+uucZ3MRpAUSmg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ]
+    },
+    "node_modules/chokidar": {
+      "version": "3.5.1",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.1.tgz",
+      "integrity": "sha512-9+s+Od+W0VJJzawDma/gvBNQqkTiqYTWLuZoyAsivsI4AaWTCzHG06/TMjsf1cYe9Cb97UCEhjz7HvnPk2p/tw==",
+      "dev": true,
+      "dependencies": {
+        "anymatch": "~3.1.1",
+        "braces": "~3.0.2",
+        "glob-parent": "~5.1.0",
+        "is-binary-path": "~2.1.0",
+        "is-glob": "~4.0.1",
+        "normalize-path": "~3.0.0",
+        "readdirp": "~3.5.0"
+      },
+      "engines": {
+        "node": ">= 8.10.0"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.1"
+      }
+    },
+    "node_modules/cliui": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+      "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
+      "dev": true,
+      "dependencies": {
+        "string-width": "^4.2.0",
+        "strip-ansi": "^6.0.1",
+        "wrap-ansi": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "dev": true,
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "dev": true
+    },
+    "node_modules/colorette": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/colorette/-/colorette-1.2.2.tgz",
+      "integrity": "sha512-MKGMzyfeuutC/ZJ1cba9NqcNpfeqMUcYmyF1ZFY6/Cn7CNSAKx6a+s48sqLqyAiZuaP2TcqMhoo+dlwFnVxT9w==",
+      "dev": true
+    },
+    "node_modules/dependency-graph": {
+      "version": "0.11.0",
+      "resolved": "https://registry.npmjs.org/dependency-graph/-/dependency-graph-0.11.0.tgz",
+      "integrity": "sha512-JeMq7fEshyepOWDfcfHK06N3MhyPhz++vtqWhMT5O9A3K42rdsEDpfdVqjaqaAhsw6a+ZqeDvQVtD0hFHQWrzg==",
+      "dev": true,
+      "engines": {
+        "node": ">= 0.6.0"
+      }
+    },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.1.tgz",
+      "integrity": "sha512-FKbOCOQ5QRB3VlIbl1LZQefWIYwszlBloaXcY2rbfpu9ioJnNh3TK03YtIDKDo3WKBi8u+YV4+Fn2CkEozgf4w==",
+      "dev": true
+    },
+    "node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "dev": true
+    },
+    "node_modules/escalade": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.2.tgz",
+      "integrity": "sha512-ErCHMCae19vR8vQGe50xIsVomy19rg6gFu3+r3jkEO46suLMWBksvVyoGgQV+jOfl84ZSOSlmv6Gxa89PmTGmA==",
+      "dev": true,
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/fast-glob": {
+      "version": "3.3.2",
+      "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.2.tgz",
+      "integrity": "sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow==",
+      "dev": true,
+      "dependencies": {
+        "@nodelib/fs.stat": "^2.0.2",
+        "@nodelib/fs.walk": "^1.2.3",
+        "glob-parent": "^5.1.2",
+        "merge2": "^1.3.0",
+        "micromatch": "^4.0.4"
+      },
+      "engines": {
+        "node": ">=8.6.0"
+      }
+    },
+    "node_modules/fastq": {
+      "version": "1.17.1",
+      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.17.1.tgz",
+      "integrity": "sha512-sRVD3lWVIXWg6By68ZN7vho9a1pQcN/WBFaAAsDDFzlJjvoGx0P8z7V1t72grFJfJhu3YPZBuu25f7Kaw2jN1w==",
+      "dev": true,
+      "dependencies": {
+        "reusify": "^1.0.4"
+      }
+    },
+    "node_modules/fill-range": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+      "dev": true,
+      "dependencies": {
+        "to-regex-range": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/fraction.js": {
+      "version": "4.3.7",
+      "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-4.3.7.tgz",
+      "integrity": "sha512-ZsDfxO51wGAXREY55a7la9LScWpwv9RxIrYABrlvOFBlH/ShPnrtsXeuUIfXKKOVicNxQ+o8JTbJvjS4M89yew==",
+      "dev": true,
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "type": "patreon",
+        "url": "https://github.com/sponsors/rawify"
+      }
+    },
+    "node_modules/fs-extra": {
+      "version": "11.2.0",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.2.0.tgz",
+      "integrity": "sha512-PmDi3uwK5nFuXh7XDTlVnS17xJS7vW36is2+w3xcv8SVxiB4NyATf4ctkVY5bkSjX0Y4nbvZCq1/EjtEyr9ktw==",
+      "dev": true,
+      "dependencies": {
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=14.14"
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
+      "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
+      "dev": true,
+      "hasInstallScript": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/get-caller-file": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+      "dev": true,
+      "engines": {
+        "node": "6.* || 8.* || >= 10.*"
+      }
+    },
+    "node_modules/get-stdin": {
+      "version": "9.0.0",
+      "resolved": "https://registry.npmjs.org/get-stdin/-/get-stdin-9.0.0.tgz",
+      "integrity": "sha512-dVKBjfWisLAicarI2Sf+JuBE/DghV4UzNAVe9yhEJuzeREd3JhOTE9cUaJTeSa77fsbQUK3pcOpJfM59+VKZaA==",
+      "dev": true,
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/glob-parent": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "dev": true,
+      "dependencies": {
+        "is-glob": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/globby": {
+      "version": "14.0.2",
+      "resolved": "https://registry.npmjs.org/globby/-/globby-14.0.2.tgz",
+      "integrity": "sha512-s3Fq41ZVh7vbbe2PN3nrW7yC7U7MFVc5c98/iTl9c2GawNMKx/J648KQRW6WKkuU8GIbbh2IXfIRQjOZnXcTnw==",
+      "dev": true,
+      "dependencies": {
+        "@sindresorhus/merge-streams": "^2.1.0",
+        "fast-glob": "^3.3.2",
+        "ignore": "^5.2.4",
+        "path-type": "^5.0.0",
+        "slash": "^5.1.0",
+        "unicorn-magic": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/graceful-fs": {
+      "version": "4.2.11",
+      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
+      "dev": true
+    },
+    "node_modules/ignore": {
+      "version": "5.3.1",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.1.tgz",
+      "integrity": "sha512-5Fytz/IraMjqpwfd34ke28PTVMjZjJG2MPn5t7OE4eUCUNf8BAa7b5WUS9/Qvr6mwOQS7Mk6vdsMno5he+T8Xw==",
+      "dev": true,
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/is-binary-path": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
+      "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+      "dev": true,
+      "dependencies": {
+        "binary-extensions": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-glob": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.1.tgz",
+      "integrity": "sha512-5G0tKtBTFImOqDnLB2hG6Bp2qcKEFduo4tZu9MT/H6NQv/ghhy30o55ufafxJ/LdH79LLs2Kfrn85TLKyA7BUg==",
+      "dev": true,
+      "dependencies": {
+        "is-extglob": "^2.1.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.12.0"
+      }
+    },
+    "node_modules/jsonfile": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz",
+      "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==",
+      "dev": true,
+      "dependencies": {
+        "universalify": "^2.0.0"
+      },
+      "optionalDependencies": {
+        "graceful-fs": "^4.1.6"
+      }
+    },
+    "node_modules/lilconfig": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.2.tgz",
+      "integrity": "sha512-eop+wDAvpItUys0FWkHIKeC9ybYrTGbU41U5K7+bttZZeohvnY7M9dZ5kB21GNWiFT2q1OoPTvncPCgSOVO5ow==",
+      "dev": true,
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/antonk52"
+      }
+    },
+    "node_modules/lodash.difference": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/lodash.difference/-/lodash.difference-4.5.0.tgz",
+      "integrity": "sha1-nMtOUF1Ia5FlE0V3KIWi3yf9AXw=",
+      "dev": true
+    },
+    "node_modules/lodash.forown": {
+      "version": "4.4.0",
+      "resolved": "https://registry.npmjs.org/lodash.forown/-/lodash.forown-4.4.0.tgz",
+      "integrity": "sha1-hRFc8E9z75ZuztUlEdOJPMRmg68=",
+      "dev": true
+    },
+    "node_modules/lodash.get": {
+      "version": "4.4.2",
+      "resolved": "https://registry.npmjs.org/lodash.get/-/lodash.get-4.4.2.tgz",
+      "integrity": "sha1-LRd/ZS+jHpObRDjVNBSZ36OCXpk=",
+      "dev": true
+    },
+    "node_modules/lodash.groupby": {
+      "version": "4.6.0",
+      "resolved": "https://registry.npmjs.org/lodash.groupby/-/lodash.groupby-4.6.0.tgz",
+      "integrity": "sha1-Cwih3PaDl8OXhVwyOXg4Mt90A9E=",
+      "dev": true
+    },
+    "node_modules/lodash.sortby": {
+      "version": "4.7.0",
+      "resolved": "https://registry.npmjs.org/lodash.sortby/-/lodash.sortby-4.7.0.tgz",
+      "integrity": "sha1-7dFMgk4sycHgsKG0K7UhBRakJDg=",
+      "dev": true
+    },
+    "node_modules/merge2": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
+      "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
+      "dev": true,
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/micromatch": {
+      "version": "4.0.7",
+      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.7.tgz",
+      "integrity": "sha512-LPP/3KorzCwBxfeUuZmaR6bG2kdeHSbe0P2tY3FLRU4vYrjYz5hI4QZwV0njUx3jeuKe67YukQ1LSPZBKDqO/Q==",
+      "dev": true,
+      "dependencies": {
+        "braces": "^3.0.3",
+        "picomatch": "^2.3.1"
+      },
+      "engines": {
+        "node": ">=8.6"
+      }
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.7",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.7.tgz",
+      "integrity": "sha512-eSRppjcPIatRIMC1U6UngP8XFcz8MQWGQdt1MTBQ7NaAmvXDfvNxbvWV3x2y6CdEUciCSsDHDQZbhYaB8QEo2g==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/node-releases": {
+      "version": "2.0.18",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.18.tgz",
+      "integrity": "sha512-d9VeXT4SJ7ZeOqGX6R5EM022wpL+eWPooLI+5UpWn2jCT1aosUQEhQP214x33Wkwx3JQMvIm+tIoVOdodFS40g==",
+      "dev": true
+    },
+    "node_modules/normalize-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/normalize-range": {
+      "version": "0.1.2",
+      "resolved": "https://registry.npmjs.org/normalize-range/-/normalize-range-0.1.2.tgz",
+      "integrity": "sha1-LRDAa9/TEuqXd2laTShDlFa3WUI=",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/path-type": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/path-type/-/path-type-5.0.0.tgz",
+      "integrity": "sha512-5HviZNaZcfqP95rwpv+1HDgUamezbqdSYTyzjTvwtJSnIH+3vnbmWsItli8OFEndS984VT55M3jduxZbX351gg==",
+      "dev": true,
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/picocolors": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.1.tgz",
+      "integrity": "sha512-anP1Z8qwhkbmu7MFP5iTt+wQKXgwzf7zTyGlcdzabySa9vd0Xt392U0rVmz9poOaBj0uHJKyyo9/upk0HrEQew==",
+      "dev": true
+    },
+    "node_modules/picomatch": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "dev": true,
+      "engines": {
+        "node": ">=8.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/pify": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz",
+      "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.4.40",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.40.tgz",
+      "integrity": "sha512-YF2kKIUzAofPMpfH6hOi2cGnv/HrUlfucspc7pDyvv7kGdqXrfj8SCl/t8owkEgKEuu8ZcRjSOxFxVLqwChZ2Q==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "dependencies": {
+        "nanoid": "^3.3.7",
+        "picocolors": "^1.0.1",
+        "source-map-js": "^1.2.0"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/postcss-cli": {
+      "version": "11.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-cli/-/postcss-cli-11.0.0.tgz",
+      "integrity": "sha512-xMITAI7M0u1yolVcXJ9XTZiO9aO49mcoKQy6pCDFdMh9kGqhzLVpWxeD/32M/QBmkhcGypZFFOLNLmIW4Pg4RA==",
+      "dev": true,
+      "dependencies": {
+        "chokidar": "^3.3.0",
+        "dependency-graph": "^0.11.0",
+        "fs-extra": "^11.0.0",
+        "get-stdin": "^9.0.0",
+        "globby": "^14.0.0",
+        "picocolors": "^1.0.0",
+        "postcss-load-config": "^5.0.0",
+        "postcss-reporter": "^7.0.0",
+        "pretty-hrtime": "^1.0.3",
+        "read-cache": "^1.0.0",
+        "slash": "^5.0.0",
+        "yargs": "^17.0.0"
+      },
+      "bin": {
+        "postcss": "index.js"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "postcss": "^8.0.0"
+      }
+    },
+    "node_modules/postcss-load-config": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-5.1.0.tgz",
+      "integrity": "sha512-G5AJ+IX0aD0dygOE0yFZQ/huFFMSNneyfp0e3/bT05a8OfPC5FUoZRPfGijUdGOJNMewJiwzcHJXFafFzeKFVA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "dependencies": {
+        "lilconfig": "^3.1.1",
+        "yaml": "^2.4.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "peerDependencies": {
+        "jiti": ">=1.21.0",
+        "postcss": ">=8.0.9",
+        "tsx": "^4.8.1"
+      },
+      "peerDependenciesMeta": {
+        "jiti": {
+          "optional": true
+        },
+        "postcss": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/postcss-reporter": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/postcss-reporter/-/postcss-reporter-7.0.2.tgz",
+      "integrity": "sha512-JyQ96NTQQsso42y6L1H1RqHfWH1C3Jr0pt91mVv5IdYddZAE9DUZxuferNgk6q0o6vBVOrfVJb10X1FgDzjmDw==",
+      "dev": true,
+      "dependencies": {
+        "colorette": "^1.2.1",
+        "lodash.difference": "^4.5.0",
+        "lodash.forown": "^4.4.0",
+        "lodash.get": "^4.4.2",
+        "lodash.groupby": "^4.6.0",
+        "lodash.sortby": "^4.7.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/postcss/"
+      },
+      "peerDependencies": {
+        "postcss": "^8.1.0"
+      }
+    },
+    "node_modules/postcss-value-parser": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz",
+      "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==",
+      "dev": true
+    },
+    "node_modules/pretty-hrtime": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/pretty-hrtime/-/pretty-hrtime-1.0.3.tgz",
+      "integrity": "sha1-t+PqQkNaTJsnWdmeDyAesZWALuE=",
+      "dev": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/queue-microtask": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
+      "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ]
+    },
+    "node_modules/read-cache": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz",
+      "integrity": "sha1-5mTvMRYRZsl1HNvo28+GtftY93Q=",
+      "dev": true,
+      "dependencies": {
+        "pify": "^2.3.0"
+      }
+    },
+    "node_modules/readdirp": {
+      "version": "3.5.0",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.5.0.tgz",
+      "integrity": "sha512-cMhu7c/8rdhkHXWsY+osBhfSy0JikwpHK/5+imo+LpeasTF8ouErHrlYkwT0++njiyuDvc7OFY5T3ukvZ8qmFQ==",
+      "dev": true,
+      "dependencies": {
+        "picomatch": "^2.2.1"
+      },
+      "engines": {
+        "node": ">=8.10.0"
+      }
+    },
+    "node_modules/require-directory": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+      "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/reusify": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz",
+      "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==",
+      "dev": true,
+      "engines": {
+        "iojs": ">=1.0.0",
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/run-parallel": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
+      "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "dependencies": {
+        "queue-microtask": "^1.2.2"
+      }
+    },
+    "node_modules/slash": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/slash/-/slash-5.1.0.tgz",
+      "integrity": "sha512-ZA6oR3T/pEyuqwMgAKT0/hAv8oAXckzbkmR0UkUosQ+Mc4RxGoJkRmwHgHufaenlyAgE1Mxgpdcrf75y6XcnDg==",
+      "dev": true,
+      "engines": {
+        "node": ">=14.16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.0.tgz",
+      "integrity": "sha512-itJW8lvSA0TXEphiRoawsCksnlf8SyvmFzIhltqAHluXd88pkCd+cXJVHTDwdCr0IzwptSm035IHQktUu1QUMg==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "dev": true,
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "dev": true,
+      "dependencies": {
+        "is-number": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=8.0"
+      }
+    },
+    "node_modules/unicorn-magic": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.1.0.tgz",
+      "integrity": "sha512-lRfVq8fE8gz6QMBuDM6a+LO3IAzTi05H6gCVaUpir2E1Rwpo4ZUog45KpNXKC/Mn3Yb9UDuHumeFTo9iV/D9FQ==",
+      "dev": true,
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/universalify": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+      "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+      "dev": true,
+      "engines": {
+        "node": ">= 10.0.0"
+      }
+    },
+    "node_modules/update-browserslist-db": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.0.tgz",
+      "integrity": "sha512-EdRAaAyk2cUE1wOf2DkEhzxqOQvFOoRJFNS6NeyJ01Gp2beMRpBAINjM2iDXE3KCuKhwnvHIQCJm6ThL2Z+HzQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "dependencies": {
+        "escalade": "^3.1.2",
+        "picocolors": "^1.0.1"
+      },
+      "bin": {
+        "update-browserslist-db": "cli.js"
+      },
+      "peerDependencies": {
+        "browserslist": ">= 4.21.0"
+      }
+    },
+    "node_modules/wrap-ansi": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "dev": true,
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/y18n": {
+      "version": "5.0.8",
+      "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
+      "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
+      "dev": true,
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/yaml": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.5.0.tgz",
+      "integrity": "sha512-2wWLbGbYDiSqqIKoPjar3MPgB94ErzCtrNE1FdqGuaO0pi2JGjmE8aW8TDZwzU7vuxcGRdL/4gPQwQ7hD5AMSw==",
+      "dev": true,
+      "bin": {
+        "yaml": "bin.mjs"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/yargs": {
+      "version": "17.7.2",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
+      "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
+      "dev": true,
+      "dependencies": {
+        "cliui": "^8.0.1",
+        "escalade": "^3.1.1",
+        "get-caller-file": "^2.0.5",
+        "require-directory": "^2.1.1",
+        "string-width": "^4.2.3",
+        "y18n": "^5.0.5",
+        "yargs-parser": "^21.1.1"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/yargs-parser": {
+      "version": "21.1.1",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+      "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
+      "dev": true,
+      "engines": {
+        "node": ">=12"
+      }
+    }
+  }
+}
diff --git a/package.json b/package.json
new file mode 100644
index 00000000..35ba87e9
--- /dev/null
+++ b/package.json
@@ -0,0 +1,25 @@
+{
+  "name": "tinygo-site",
+  "version": "1.0.0",
+  "description": "TinyGo website",
+  "main": "index.js",
+  "dependencies": {},
+  "devDependencies": {
+    "autoprefixer": "^10.4.19",
+    "postcss": "^8.4.40",
+    "postcss-cli": "^11.0.0"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tinygo-org/tinygo-site.git"
+  },
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/tinygo-org/tinygo-site/issues"
+  },
+  "homepage": "https://github.com/tinygo-org/tinygo-site#readme"
+}
diff --git a/static/favicons/_head.html b/static/favicons/_head.html
new file mode 100644
index 00000000..08692eec
--- /dev/null
+++ b/static/favicons/_head.html
@@ -0,0 +1,5 @@
+<link rel="icon" type="image/png" href="/favicons/favicon-16x16.png" sizes="16x16">
+<link rel="icon" type="image/png" href="/favicons/favicon-32x32.png" sizes="32x32">
+<link rel="icon" type="image/png" href="/favicons/android-192x192.png" sizes="192x192">
+<link rel="apple-touch-icon" href="/favicons/apple-touch-icon-180x180.png" sizes="180x180">
+<meta name="msapplication-config" content="/favicons/browserconfig.xml">
\ No newline at end of file
diff --git a/static/favicons/apple-touch-icon-180x180.png b/static/favicons/apple-touch-icon-180x180.png
new file mode 100644
index 00000000..d44aa030
Binary files /dev/null and b/static/favicons/apple-touch-icon-180x180.png differ
diff --git a/static/favicons/browserconfig.xml b/static/favicons/browserconfig.xml
new file mode 100644
index 00000000..85cb4cc4
--- /dev/null
+++ b/static/favicons/browserconfig.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<browserconfig>
+  <msapplication>
+    <tile>
+    <square70x70logo src="/favicons/tile70x70.png" />
+    <square150x150logo src="/favicons/tile150x150.png" />
+    <wide310x150logo src="/favicons/tile310x150.png" />
+    <square310x310logo src="/favicons/tile310x310.png" />
+    <tilecolor>transparent</tilecolor>
+    </tile>
+  </msapplication>
+</browserconfig>
\ No newline at end of file
diff --git a/static/favicons/favicon-16x16.png b/static/favicons/favicon-16x16.png
new file mode 100644
index 00000000..dd90713f
Binary files /dev/null and b/static/favicons/favicon-16x16.png differ
diff --git a/static/favicons/favicon-32x32.png b/static/favicons/favicon-32x32.png
new file mode 100644
index 00000000..7af273c7
Binary files /dev/null and b/static/favicons/favicon-32x32.png differ
diff --git a/static/favicons/favicon.ico b/static/favicons/favicon.ico
new file mode 100644
index 00000000..067d2a60
Binary files /dev/null and b/static/favicons/favicon.ico differ
diff --git a/static/favicons/pwa-192x192.png b/static/favicons/pwa-192x192.png
new file mode 100644
index 00000000..51536ee5
Binary files /dev/null and b/static/favicons/pwa-192x192.png differ
diff --git a/static/favicons/pwa-512x512.png b/static/favicons/pwa-512x512.png
new file mode 100644
index 00000000..54d668db
Binary files /dev/null and b/static/favicons/pwa-512x512.png differ
diff --git a/static/favicons/tile150x150.png b/static/favicons/tile150x150.png
new file mode 100644
index 00000000..3a49d0d5
Binary files /dev/null and b/static/favicons/tile150x150.png differ
diff --git a/static/favicons/tile310x150.png b/static/favicons/tile310x150.png
new file mode 100644
index 00000000..c4992826
Binary files /dev/null and b/static/favicons/tile310x150.png differ
diff --git a/static/favicons/tile310x310.png b/static/favicons/tile310x310.png
new file mode 100644
index 00000000..ff0f7260
Binary files /dev/null and b/static/favicons/tile310x310.png differ
diff --git a/static/favicons/tile70x70.png b/static/favicons/tile70x70.png
new file mode 100644
index 00000000..02704979
Binary files /dev/null and b/static/favicons/tile70x70.png differ
diff --git a/static/images/i2c-lis3dh-acceldata.png b/static/images/i2c-lis3dh-acceldata.png
new file mode 100644
index 00000000..ce92b0fd
Binary files /dev/null and b/static/images/i2c-lis3dh-acceldata.png differ
diff --git a/static/images/i2c-lis3dh-config.png b/static/images/i2c-lis3dh-config.png
new file mode 100644
index 00000000..590ee923
Binary files /dev/null and b/static/images/i2c-lis3dh-config.png differ
diff --git a/static/images/i2c-lis3dh-who-am-i.png b/static/images/i2c-lis3dh-who-am-i.png
new file mode 100644
index 00000000..d3ed8010
Binary files /dev/null and b/static/images/i2c-lis3dh-who-am-i.png differ
diff --git a/static/images/i2c-mpu6050-whoami.png b/static/images/i2c-mpu6050-whoami.png
new file mode 100644
index 00000000..99b7e344
Binary files /dev/null and b/static/images/i2c-mpu6050-whoami.png differ
diff --git a/static/images/i2c-target-flow.png b/static/images/i2c-target-flow.png
new file mode 100644
index 00000000..bf816395
Binary files /dev/null and b/static/images/i2c-target-flow.png differ
diff --git a/static/images/tinygo-logo-10.svg b/static/images/tinygo-logo-10.svg
new file mode 100644
index 00000000..8f932403
--- /dev/null
+++ b/static/images/tinygo-logo-10.svg
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="30px" height="26px" viewBox="0 0 30 26" enable-background="new 0 0 30 26" xml:space="preserve">  <image id="image0" width="30" height="26" x="0" y="0"
+    href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAB4AAAAaCAYAAACgoey0AAAABGdBTUEAALGPC/xhBQAAACBjSFJN
+AAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAABmJLR0QA/wD/AP+gvaeTAAAA
+CXBIWXMAABTqAAAU6gFxlYZXAAAAB3RJTUUH5QUEDAse3T4legAAB9ZJREFUSMeNVs1vHEkV/1VX
+Tfd0d7p7vsc4mXg9cSInzubb4HygEFYJu1pFiZCQIDnAckDkygUOKIeVkBaxEfsXIKEVEUdOoGhh
+E7EKRN4sSjaOw9qJY894PDOe8Xg+e7p7uro4eMaJjZF4t6p69V7/3vvV+zVB34QQGBkZ+YVhGDcJ
+IbIQQmCbEUIk13WXyuXyVV3XvwSATqdzJJ1O/0lRlBEhRLDDHSKE8JrN5vu5XO4DQsjG/o0bN67E
+YrGxUCg0cffu3W83m80RXdehqip2MiGE4Jx/oSjKXwDAdd13KKUnySDiNut2u+h0OjBNc+nChQuf
+9nq9Z9VqdY5Fo9FfJ5PJIcaYaVkWiUajuHbtGizL2jFxH8EpIcSp/hqEEOxQIABAo9HA7du3EQTB
+SCKR+JHv+y0hRJHNzMx8f2ho6Ou6rr9drVbPTk1Npfbv348gCOD3epAoBaUUBAAPAriOA8d14Hk9
+AEAoxBAOqwgrCogkQQix8SFBACIRpFIpZLNZPHjwYHVhYeF+p9O5UywWp9nExMTvUqnUMGMsOj8/
+z4QQEEKgVCrh8VcLMLQwDo2NorJWQ7FSg8MBwmRIVAYABLwH4btQGcHudBzDQ0N4mcujXK3hQHYE
+u4eHIYRALBZLjI6Ovuv7/tlYLFZg9Xr9I0LIEcbYVLvdniCERAghWC6WwGULzwsFLC4XsXvsMOJj
+JxBWNUgSxaCjQgCc+3DsDvLlZTya/Qxtx0cyk8XzpQKGh4YAAO12u1mpVJ76vj9dr9cfSeFweFzT
+tKyqqgnGWGiAOBmPobj4FUpL84jFE2CBi0a1hIBzAAJBEPT7KkAphe/3IHgPmhFBvVLAwuwjaEoI
+RJIAAIyxkKqqCU3TRsPh8DiTZfmgoihvUErjjDF5QAoqSRgbjuMHV99GpVLBm4cPY7W6humZGQyN
+vQnG2EY/JQmVQg6kVcSFE0dQWCngwjeOory6itpaFUEQDBLLiqLEOeejsixDWl5e/m0+n/+4WCxO
+t9vtBiEEjuOgVCri+vXraLfbuHXrFgqFAs5MTeHUoVGsFXObbHa7NtxaHt+78i4A4MMPf4OlpUVc
+vXIFIyNvYGVlBZIkod1uN0ql0nQ+n/84n89/RC9fvvxpJpO5HI/HDy0vL+uJRALpdAqmaeH48eNQ
+FBkRy8K5c9+EpmkwjV348ukstEgKkiRhbXUFo8ldOHb0KHRdRzabxZkzZ6HrOkzTxOzsLFZWVtDt
+drXJyckxy7LOhUKhi2xubu5avV4/parqpVqtdpoQkux2u9izZw8AIJPZi/fe+/Hmu9RUDQqTAAhI
+lMJzbMQyGwQyTRMXL17a9DUMA5RScM5Rq9VWFxYWHti2/Um5XP6cjY2NfZBMJjOMseSzZ880ITbI
+4rrujgPB8zw4Xg/r87NA39e27R19OecQIgAhBJZlxTKZzLd8358wTTPPut3un1ut1iFK6THHcbJC
+CNOyIigUCrBtG5qmbQn24uUiFhYWMDP9GSgRODh5Hoo7hNNTHei6vsV3dXUVhBBQSuE4jt1sNhc4
+549t256VgiDoCSH81we8YRj499w8Hj58CNdxNkXk5cuX+Ns/Pkdgr+P85CFcvXQWI5bAUrmGO5/8
+Fe12azOp4zi4d+8eYrE4BmNcCBEIIXpCCI/puv5dy7IylNJEOBxWhRAIOIdiJnH/8RwW8wVEIxG0
+7C7KDQfRzDjKpSJq6wUQhaMLhoMnz2Ju+SWWfn8b+0b2QFVVLBXKeL64gtHRUQghEA6HdcuyDnDO
+Y67rjrO5ubmfNRqNSVVVv9NoNM4QQpKcc4T1XdgzfhKtxjoKXQ+KHsHutAVKJUycvoT5h3dBZIqR
+sZOwogkYVgztVh2L9RrQsGEmRpF0BXzfByEEjUajlsvl/mnb9p1yuTzNxsfH/5hOp9OMMX1+fp4A
+6D96AsoYookUSL/UgzNN34XssXPwXBdWPNknEGCYEZhWdCBjWFshECIYzOpkNpu97Pv+W9FotMRy
+udxPbNs+IcvyW/V6/RSARCAEQAhIfxgPBO916bOi8U3FGuz/lzz214QQ1Ov1ai6Xe+i67t1KpfKQ
+DQ8P/zSZTGYppXt0XTdfJdiq64MAYZnBUGXIbGMG9/wAra6Hrudv+qB/m4AgCDZmv67rZjqdPs45
+T8qyPMk45znP88KUUpNzbgCQsc0GAU1NRnRXGLQ/+AFACQGqwlBp2Og4vW0/Da/0mXPue57X5JwX
+fd9fYu12+1+yLPuMsYjneQkAGnYwVWaI7lJBJbIFmRACVJIQ0cNwPA4eBP0zApBX7fE8z+10OiXf
+9591Op3HLB6P/zyVSn2NMRYxDIP1W7Mj2u1JB33dQE6hhChsN3gdMgYMMQwjkk6np3zfPwigyJ4+
+ffrDarU6qWnaO7Va7SwhJEU2PnXzPqMSlBDbkmi7EUL6iV8rt9joMwDUarXKixcv7tu2vfnr84c+
+Yuv58+eS67objJYkSBKFgIASCiHE2P9I+orRqiKj2fUBbOg0IQCRCDzPQywWS+3bt++K7/sX4vF4
+kdXr9ZuSJB1gjB1sNpvnZ2Zm9uq6hrYHtFstAAKMUmgKA8Gr0u1kPg9gu/5mmavFHPJPXDx58gRB
+EOTW1tb+3uv1nq2vr89tgbB3795fGoZxE0CIDN7xJqb/z14PKLBJLq/Var2fy+V+NTj7D7773eJp
+jjvJAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDIxLTA1LTA0VDEyOjExOjMwKzAwOjAwrJ8kLwAAACV0
+RVh0ZGF0ZTptb2RpZnkAMjAyMS0wNS0wNFQxMjoxMTozMCswMDowMN3CnJMAAAAASUVORK5CYII=" />
+</svg>
diff --git a/static/images/tinygo-logo-20.svg b/static/images/tinygo-logo-20.svg
new file mode 100644
index 00000000..87d192e7
--- /dev/null
+++ b/static/images/tinygo-logo-20.svg
@@ -0,0 +1,110 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="60px" height="51px" viewBox="0 0 60 51" enable-background="new 0 0 60 51" xml:space="preserve">  <image id="image0" width="60" height="51" x="0" y="0"
+    href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADwAAAAzCAYAAADLqmunAAAABGdBTUEAALGPC/xhBQAAACBjSFJN
+AAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAABmJLR0QA/wD/AP+gvaeTAAAA
+CXBIWXMAABTqAAAU6gFxlYZXAAAAB3RJTUUH5QUEDAo1aJntewAAFoVJREFUaN61emlwW9eV5vf2
+DQ/7QkIUQRDcRImULEVyRNqOVPESx7HkLMrIXeks1enqdieVlLsm+THzI5XqznRN1cxUT9LpTKZS
+cdp2u2O7rZTkKkujyIss2RZlS5ZEiaS4QBBIilgIkNgeH/Dw3p0fJGiCi2Spu49KBRR437nfd+65
+555z7qOwsShut/s/OxyO77As6wdAAyC4e6Eymcwfs9nsVwFUNhgjuN3u1zwez8P3OgcAq1qtpnK5
+3G+z2ez/BFBabyBb++L3+xGJRLBlyxaEQiH89Kc/fcDj8fzYbrfL9wBgtfTpun5Q07RX7XY7FhYW
+QFEURFFEPp+HLMsHPB5Pn91uF/6N84RYlv3x/Pz8uZ/85Ccnp6amcO3aNUSjUSQSCQAAc+bMGTz3
+3HOwLMvu9/sjDMM8WCwWP0cI+RJN07tYdtEmhJB7/s9xnMTz/OdomvaWSiXdMAyYpum0LKvH5XL9
+lc/n+682m817r/MAAEVRNZx8Q0MDxfN8IJfLNRcKBWZqaqpcqVQqp0+fBnXgwIH/HgqFvIqidNts
+thZJkjyCIHCDg4N47733IAgCLMsCTdNwOByQJOmezW+aJgzDyBNCsgBA07SbZVk7wzD3rHNhYQG5
+XG4ZY7lcRn9/P3p6elCpVAxN07LFYvFmoVC4dvPmzTTb1tb2487OzpUWAk3TqK2sZVnw+/148skn
+0dbWBkG4d6+jKAqEEDsA+6rf7llnuVzG+Pg4Xn/9daRSKQAAy7IQBAEcx3E2my3g9/sDhJA9giCA
+TSQSb8uy7JBluVkURZcgCAzHcXUgDx48iL6+Ppim+W8C9x8hdrsdDQ0NoGkav/nNb5Z/J4SgWq2i
+UqmYCwsL85qmTSYSiTn2pZdeetzj8UidnZ2bfD5ft8Ph2C3LcnB4eLiNEHI/x3Hw+/2wLOuuyRJC
+lj1n9efKMas/V4+50xw1L+Q4DuVyGVevXh0wTXNc1/VbuVzuQiqVGhoeHp7KZrMa63A4lGAwqDgc
+Do+iKH5FUTyyLPskSVJXg1oJiAJQNc0616+5J0VRoCgKNE2jWq2iXNaxoC2gpJWgaRoMwwAAcBwH
+SRQhKzbYFAWiKIJhmLqAtFpnzRi1BVi5FWsiSZKqKIqPpulKtVr1qarqCQaDOcuywB44cOBUW1ub
+Q5KkgCiKCsdxYFkW5XIZU1NT665YPp/H2++8g9TsLLxuNx7o74ff7wchBAzDQNM0TE9NYSI6gVuJ
+JIoLZZgWwPAiOF4ERdOL+iwTVaMC0yiDgQWHTcbmpk2ItEbQ0NgInueXDQkAk5NxRKM3IIkiurdu
+haIoa7yOoii0tbV1d3V1dVerVRiG8R1d17WFhYXkxMTEHOvxeO7z+/2gafqOAaQ28ZtvvYW8JaLn
+cwcxHRvHy6/9AYe/9mXwPI8LFy5geGwChJXgbwqj9TPbYHe6IUoyWI4HwzBAzWWX3LFqVKCVipib
+TWJ68gYuHz8FmQW292zFtm09kGUZZ86cwcDHg2gMd6I4NY2R0TF8/dDXbhtEaZqGKIoQBEFWVTU8
+NzcXZoeGhn5QKpUaVVXtUVW1Q1GUgCAIgq7rDAButZJyWcetRAo7H/4KnG4vzKoBYln47XPPQbI5
+4Ghowa6HvwqvvxEsx4GQmruRZZKffF8ExQsieEGCy+tHpKsH5bKOxGQMH186j4uXrqAx4MP12DQe
++OLXUa2U0bg5jD8eeR6Tk3F0dHSuIarruqFpmlkulyulUilZKBTG8/n85Xg8PsN6PJ5fPPHEE3jq
+qae4QCDQ0tHRsdfhcLTHYrH7LMt6Yq3VGLAsg2wqgYmhS5iMjkFSFLCqH3sf/wr8wc0AITBNc80+
+W3KTFd/rNgyIRWARAo7jEWrrQnOkC7fiUbx74ggYhsf8bArTN8ehOt3gBAHVanUNWcuycO7cuZOJ
+ROLjQqEwPjY2du7WrVs33njjjcoLL7wARlXVR+PxeH9/f/839uzZ8+0tW7Y8FYlE+miabksmkwLP
+8+jr64Pb7QYhBCzLIpNJIz49g7buHbh28X2UigV0bd+FbCqBWzfHUcjNg+N5CJIM6i4i78rgVMjP
+49bNKPJzGTjcXkzfjOL86f8Hu8sNEILsdBT9n90DQRBBURTm5ubw/vvvo1qt4r777mvcvXv39ubm
+5vu7urr2dnd3bx8YGGiIx+MBdteuXa93dHSwLMvSDMMsR1en07khqL2f3YvRF1/E2ZNHYZVL2NLV
+hQbRhMvlBEBhJjGJc4MfwObdjB19+6HY1Lrgs5FemqZRLORw6YN3kJ2Owu92oKEhAL8qw7ajG4O0
+gXIpj4nhK+htC8Hlcq8bcxwOh+rxeFTLsvyEkDbTNB+pVqtkdHTUYCuVSrZcLiuEEBsA6nZpXg2U
+ZVlgQNCx2YdDf/09tLe3o1AoAACCwSAAIJlM4OjRo3jn2Et44PGvweHybEi6pjeTSuDs8Vexra0Z
+f/bD76M1EoFhGEin0wgGgyCEYHDwCl544QVoWgmGYSwfixvhXUpnUalUipVKpcTouv5GOp0+Mjc3
+N5DL5eLakkSj0ers7Ky60qVrQeu1115DT08PvvvdP0drays+uvAR/umF5/Hz//33aGrajNbWVths
+Ntx3306YZQ3vvH0KzW3dYDYAR1EUFkpFnH79X/D5/t14+uk/QXMohMnJSZx5/wP83d/9DPF4DPv2
+7UcoFMKDDz6IK1cuY2JiApFIBDRNL7t0pVKBKIozoihOptPpoampqePj4+O/HRwc/PuhoaFfsd//
+/veHn3nmGfA8P9zb23s5EAjcb7PZwrFYrIcQ0rga2MDAAJxOJ5566svweDzQNA3PP/88CEVjYmIC
+Z8+ewcMPP7wU4GgcPHgQE9EoRi5/hN77H4RlmmtWmaIoXD7/LraEN+ELX3gcTqcTFEXh2LGjeO0P
+f0AyMYOqYaBUKsHpdMJut+Mv//IZ/Oxnf4vx8TF0dW2pW9VYLHaVZdmrmqbFUqnUwODg4Limadlf
+//rXhD158uQ/Pvvss15FUboURWmSJMkhCALtcrlw9uzZOmDFYhGjo6P4xjf+FG63e/FI4XkIPIdX
+XnkFHMehtbW17hmWZXHwwJP4H//wf9G1/TPg+LXnZiE/j8zUBA5/9ztwOByglxKTcDiM2WQClXIZ
+/f19sNlsK/cpDhw4iGPHjqK9vWP5d5qmsXv37ke2b9/+SKVSsRYWFvKPPvrodKFQGDlx4kSKDYfD
+z6xXLa3eyzRNY3JyEk6nEy0tLeB5HgDA8zyeffav4XS6oKoqvvSlJ9cQCodb4bHLyKSTaGwK1QUa
+iqaRmIwh6HNjU1PTsl4A+OIXn4DP50c+n8fevXvX7NcdO3bg6NE/IJvN1nkNwzBgWRY0TdOSJDnd
+breTELKVpmmwk5OTR3med8uyHJZl2ScIgrBy0pWSSMygqakJsizXTdDaGsHf/M3fbhg8eJ7H5mAj
+5jIpBDe31BMGkEnNINK0CbIsL69u7bn+/v4N9SqKgsbGIFKpJCSpvjFjWRYMw0C5XC6XSqXZUql0
+Y3JyMsO++uqrXwXAb9u2LRAMBrvcbvceRVFaRkZGOgghdbMVi0U0NDSAZdm7qmgAwG5XkUgtYFW2
+AUIAvVSAPezH3TYCKIqCx+NZahMpS/oILl269J6u66Oapt2cn58/PzU1dX1wcDABoMyGw+FAQ0OD
+GggE2p1OZ6/dbt8my7IvmUx65+fnV4Ej91ywG9Uq6CVCdRUOBYCiYFrmXesEFjM/y6rH43K5vD6f
+z9B1XRVF0RQEgZdlWUilUjl2//7970YiEVkURY8gCDzLsmAYBsViEbFYrE6RoijI5/OoVqt3VbcS
+QpBKz8Lmi6BarSCbTsIyTdhdHsg2FaJsQyabhWEYd10P5/M5yPIn7kxRFFpaWjojkUinaZqoVqtf
+K5fLhq7rmYmJiRKrqmrE5XItV0sra87V4vf7MTExAU3T4HA4PrUL5nI5TCdSaNu0FUee+wfcunEd
+AIHq9uNLT/85PP4gbgyfQ6FQgN1u/9R6DcNAIpHAnj17YBj1eXWNx1K5y0mS1KCqKthr1679WS6X
+89nt9l5VVbfYbLYmURRFTdM4AGJNgWVZaGrajIGBc0gmk3A4HFBV9VMBGxg4Bwh2zExGce2jMwiH
+QuA4DtHoCN5541/xwKNfRnq+iLGxUXi93roVu53E43EUCnn4fP662l3TNL1QKBjlclkvFou38vn8
+SC6Xuzw9PZ1k3W73b/ft24dvf/vbjMvlaunu7u5zOp2tsVhsFyGk7oxxuVxwuz344IP3EQgEwLLs
+HbuYyUQCrx8/CefmLgydO4nQpgDS6RQ4jseOrR1o9vO49N5J+De34Y3jJxAOh7FpU9Mdm4WEEJw6
+9Uc0N7fUYbAsCwMDAyeTyeTFfD4fHRkZ+SCdTsdefPHF6rFjx8Amk8mnT5065f3e9763XVXVblVV
+m0VRVK9evcp9+OGHdZPQNA3VbsfRY8fQ3b0VHR0dcLlca46pmqTTKfz8l7+Es6kDmZk4wn47tj60
+EyzLgOc4NDc1QuR5/NNrx+HybUd0KIGXX34Fhw8fRmNjIwRB2HB7fXzxIs6dO4dvfetbsCyrDuPu
+3bsf2bZt2z5d14sPPvhgPJfLDR8/fvxyMplMsb29vf/c2dlJMQyzvI9pmoaiKOtatVKuINjWg395
+9V/x9KGvIhJpg91uh6qqy4mBri/gwoULePnV1yA3tOK+3f14/flfIuCVl3tWc/OLwc/jdsIyTciK
+DX2PHMDZE0fwq1/9CgcPHEB3dzccTmfd2QwAw0ND+F8//zmsanXN+QsAiqJIDodDUlXV7vV6g5Zl
+fdY0TVy/fp2wmqbFi8WiIgiCi+d5plYibuRGC+Uytu7qg1k18Lt/fhltLU1oCYVgs9lgWRbS6TTG
+ozHkdAtbdj2EUFsXKIpCqLMHF868gYFLQ1BsjkUiFIXpRArh7p3YFIqA43nsf/Iwrpw/g1/8+jcI
+bWrA1u4t2Ny0GZIsoVgsYnh4BBeuXENo216kY0OoGgbWS5Rq3UzTNFGpVExd1+c1TSuxb7311kNj
+Y2Muv9/f6XQ6t6uq2itJki8ej/sIIa2rlVQqFXA8j7buXgQ2NSM2NoQPh2/CMCpgOR52lxctO/fD
+39gEluNByGLXo/f+h+BpaMJ7x1/FU088BqfThVQ6heuJEj7zwOeXjWx3ubH3809gLrMb8YlRvHtx
+BPqZ8wAhYDkenoYm9D1xGLKiInXjGqpmdQ3ReDwetdvt6XK5nC4UClez2ezlRCIxMj09nWWj0Wic
+oqiZcDicDoVCKY/Hk1cUpTWVSnWtJmxZFoyqCY4XQCwLdqcHO+5/aLFDRQiw1L6ttVgty1xOVBiG
+RSjShWioHWOjo1DtKqZuJRHZ/fBS8vBJFcWwLLyBILyBIEzThFmtAiBgWG552ywsaCCgYJrWmtVN
+pVJTU1NTI5qmRbPZ7IexWGw0Go2mCCEV9tChQy/86Ec/8iuKEpFluUEURYXnedhsNrz77rtrrGea
+FhimlsST+iyHkLq7zrrmOyEgINj5wMO4ePYUbkZn0NKxFYFNzSBk424IwzB153Ity6MpCqAoWKsy
+NIqisHPnzod6e3sfMgwDuq5rpVIpWSqVxg8dOpRkm5ubv9He3l6nsBa81uwLy4JFrMXAg7sUigIh
+FuxON/Y/+Z/q0tS7za4W1dEAKBCLrFtf12KRIAiyw+EIAwibpgn2xo0bv6Moymez2dplWQ5KkqTw
+PE+tDPUrjWFZiwa5l2vr1bcEq686707Z4odF1uJcEayIruulUqmUKBaLozdu3EixR44c+Q5FUUww
+GPS2trZ2eL3e+1VVbR0dHe22LOtzdYSxtBr03b0MsMjrzuPvhji15NKrCxnLsnDx4sV3isXicKlU
+is7Ozp6fmJgYm56eThNCqmx7e3t4//79bp/P17UUpXtkWfYWi0Xf6OjoKuCLe3TRnT4t2UVADE2D
+Y2nwLAOGXsxzTcuCUbVQqZqomtZdufZieFx06dWGCAaD4ZaWFpuu62Gfz9cQCASupNPpofb29gy7
+b9++0+3t7YogCE6O4+ilTgHm5uYwNja2LvhP22OuEbVJHGwiD55lQNP1z1qEwKhaKOoVFLQKzDu0
+c1cwWzLa2qC1adOmUHNzc2jJtb9QLpetSqWSGxsbK7KSJAUVRWFWZlp3nPAOf66RFTgWblWExG/c
+MKApCgLHgGdFiByLTF6DYd6ZdA2ntc6xtPLvDMNAFEWaZVmXJEl29sqVK1/PZrN+u92+3W63b1VV
+NSSKolooFAQA9XkbWelOtxeRZ+FzyOBZZvnRjZ4iSwAVkQMhEtJ5DZZ1e/emKApY6pGvlkKhoM3P
+z5d1XS8Wi8WbuVxuKJfLXZqenk6ygUDgyGOPPYZvfvObrNvtbtmyZctep9MZicViO1dXSzXE5DYB
+iBACjmXgtUvLZO/kFCv/pogcFio88lr5tkaqkV4dpS3LwkcfffRmJpO5mMvlJq5fv34ulUrFfv/7
+3xtHjhwBm8lk/uLtt9/2/vCHP9yuqmqXzWYLiqIoXLlyhTt//vz60DbgWws6TkWAwG18I7CxsRZJ
+2GUeWtlA1bTqL9/WIbw6aNE0jT179jza29u7v1wul/ft2zeTz+dHT5w4cTmTySTZbdu2/Z/Ozk7Q
+NL1clVAUtW4RXpv6disscgwUkcO9SI0bzzIQeRbFhcodBlPrYpFlWVAURZAkyeZyuTyEkG2maX7F
+4XCAzefzI9ls1iaKolcQBJHjuI1bLEu5MtZp4tVWVxF5MDR9R3e8PXEKIrdI+LZHFUXd9ngnhGAp
+vSzruj6bz+cL7Jtvvrnv6tWrakNDQ8TtdveoqrpTkqSGaDTaSAjpWrsCG3ctaZqCxC+68r2SrQnP
+0qApCha5LaN1SUaj0RFZlmd0XU/k8/nLmUxm8NatW2PpdDrPxuPxTDweL+7cuROmabKGYdhFUazk
+crk1PRYK1KJRSW396ifkGBos8+mTktsJyzJgGBpWdYP27eKrBeuufi6Xy2YymXi5XJ6cm5sbnpmZ
+Gb948eIMAJ09fPjw0XA47JJlOSTLslcQBJ7jOEiShNOnTy8SrSml8AnhtXzBMTTuJS1elzBNgWdp
+GNWN+9W1QqduUSgKO3bs6Ovt7e1bunkwNE3LPPbYY7EbN25k2WAw+MWWlpY1d0s1MU0TmqYtvaq0
++O+T5L8eAMPQ91YIrCMURUHgWJR0Y63nUliut2uZ4cLCAkzzE+PQNA2O48DzPKeqagMhpKFcLoON
+RqO/sCzLoyjKFkVRmiVJcvI8z9QerlarOHHiBBwOB7xez2LPC4sX4oRaiYSAJgSmWQXIpykVyB3H
+0bDAUEtjV0nVqgKWCYZhcPPmTZw4cWL5nY+lSgmGYVgLCwvzxWJxslAojMTj8RS1FAXpQCDg6ujo
+aPb7/d2yLPsHBwc/axjG10VRhGmacDqdaGpqQiKRgL+xCYIoroFBUxTojQLnpyiu1gwhBOsljhQA
+07IwFYvC5/UgmUxifn4eDMNA13VwHPdKT0/POV3X06lUanh0dPTmzMzMHCHEZJdyTovn+QzLspnN
+mzd/3NPTg5deeunx1tbWJ0VRlBiGQT6fx9WrV0FRFGZnZ+/RUf99haIozGUzyzkzAFQqlYWRkZHf
+/eAHPzh+7do1ZLNZ8Dz/ya3KbfSpHo/nv6x4I/7fKRz9hwmpvRGfyWT+G4DieoP+P3X284K/8yLU
+AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDIxLTA1LTA0VDEyOjEwOjUzKzAwOjAwtNpcCwAAACV0RVh0
+ZGF0ZTptb2RpZnkAMjAyMS0wNS0wNFQxMjoxMDo1MyswMDowMMWH5LcAAAAASUVORK5CYII=" />
+</svg>
diff --git a/static/images/tinygo-logo-border.png b/static/images/tinygo-logo-border.png
new file mode 100644
index 00000000..7df0b107
Binary files /dev/null and b/static/images/tinygo-logo-border.png differ
diff --git a/static/images/tinygo-logo-small.png b/static/images/tinygo-logo-small.png
index f6b51f29..eb30137b 100644
Binary files a/static/images/tinygo-logo-small.png and b/static/images/tinygo-logo-small.png differ
diff --git a/static/images/tinygo-logo.svg b/static/images/tinygo-logo.svg
new file mode 100644
index 00000000..f3045dc8
--- /dev/null
+++ b/static/images/tinygo-logo.svg
@@ -0,0 +1,563 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="299px" height="255px" viewBox="0 0 299 255" enable-background="new 0 0 299 255" xml:space="preserve">  <image id="image0" width="299" height="255" x="0" y="0"
+    href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAASsAAAD/CAYAAACpfPA5AAAABGdBTUEAALGPC/xhBQAAACBjSFJN
+AAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAABmJLR0QA/wD/AP+gvaeTAAAA
+CXBIWXMAABTqAAAU6gFxlYZXAAAAB3RJTUUH5QUEDBAvJdbu2gAAe1FJREFUeNrtnXd4G1XWxt8p
+GnW59xbLcklPnN4LJKEkQOiQpbOYupTdpeyywLIfu9Sls3hJqBt6IKRAQgohjfSe2HGTe6+y1TUz
+3x+yxpIlt7hIsvV7Hj/JSFejO6OZM+fee855CfgHKQBmApgKIB5AKIAQgiAIb3fMn+F5vhbAMm/3
+ow9sIwgi3Nud8Gd4nucBNAJoAlAG4AiAAwCKvN23nvDlmz0YwB3tf+MBgCAIXiQScTRNkzRN+3Lf
+fRqWZaHX6wGAAyAFYPF2n3qBFIAeACGXy0FRlLf747fYbDbeZrNxVquV5HnecR+dBPARgI8BtHi7
+j57wxRueAnAPgH8ACKNpmgsLCyODg4Mhk8lAkqS3++f3WK1WnDp1yrE5DsBZb/epF0wCcBwAJk6c
+CJqmvd0fv4fjOBgMBjQ3N6OhoYGz2WwkgDoATwNYDfvDzGfwtV9cBeALAJdRFMXHxsYiIiKCDIz2
+BhaRSASJRAKTyQTYh4H+YKyWAYBUKg0YqgGCJEkoFAooFArExcWRdXV1qKysDGdZNhvAcgA3A2jz
+dj8d+JIVkAPYC2CSTCZDSkoKGIbxdp+GLVVVVaisrASAc7B7V7y3+9QNJIAcAGlxcXGIjo72dn+G
+LRaLBQUFBTAajYB9Pms+AKO3+wXYLwJf4b8AJkmlUqSnpwcM1SATHh7uGFKPAXC1t/vTA9cDSCNJ
+EuHhgfn1wYRhGKSnp0MikQD2Ba3/eLtPDnzFWM0EcDNBEFCr1YF5qSFAJBIhKirKsfkagCBv96kL
+QgC8AgDR0dGBIeAQQFEU1Gq1Y/M2AFO83SfAd4zVgwAQHBzssOgBhoDo6GhIpVIASAKwBr41LQDY
+r8+PAcTLZLLA8G8IkUqlCA4Odmw+6O3+AL5jrDIBQKlUersfIwqSJJGSkgKapnkA1wD4t7f71Im3
+AVxB0zTUajUCCy1Di0qlcvw34Fk5kQQAYrHY2/0YcYjFYmg0GoKiKB7AIwCy4f1VYhHsnt79FEXx
+qampgWvDCzjNG4/ydl8A3zFW3r45RjRyuRzp6ekEwzA87DFuewAke6k7CQB2ALhTJBLxaWlphEwm
+8/YpGpE4ebI+cX/6irEK4GWkUikyMjKIdtd/JuwBmA/CHqQ7FNAAHgZwBsA8lUqFMWPGBAxVAIGA
+sQogIBKJkJqaisTERFAUpYJ9zugcgFsADNY4TAL7ilMOgDdomlYmJSUhNTU1sPIXwIXBmLFUAZhB
+kuRsqVR6kdlszrTZbPIeO0IQ0Gg0zpN6AbyIzWZDTU0NamtreY7jCNjzxb4E8BmA/ehfECkBYC7s
+RvAGACqSJPnIyEgiKioqYKR8BJ1Oh4KCAthzn7uHpmm9WCw+ZjQat3Mc9xuAgwB0A9mfgTBWagBz
+RSLRLJqmLzKbzeqQkBCDWq1m0tPTxSkpKYiJiel2JWft2rXYu3cvUlJSAsbKx2BZFk1NTWhoaEBb
+mz3zgiCIGp7n9wM43P53CkBtN7uJAjABwDQA0wHMAhAJAAqFAmFhYQgJCQkkJ/sYOp0OhYWFmDt3
+LlatWtVt2+bmZhQWFiIvL89aWFhorKiokDMMUw9gt8lk2gd7dspx9CPfsK+PMCWAiSRJzpNKpcvM
+ZvMUkUhEJiUlsRqNRqHRaIj2NJlADMIwgaIohIeHIzw8HGazGU1NTWhra4vS6/VX2Gy2lU5NrQRB
+1MNewaEZ9qoZYp7nw2Bf3QMA0DTNKhQKSi6XIzQ0NJCpMEwIDg7GlClTMGXKFBEAkcViQWlpaVRJ
+Scl1RUVFy3Nzc3mj0UiJxeI8i8Wy1Waz7YbdQ2/o7Xf0ZKzUAOaKxeJZJEkKXlNGRgaTlpYmTkxM
+7NFrCjB8EIvFzoGZlMVigV6vh9lshtVqFdlsthie58GybBJFUSAIAjRNg2EYiMViyGQyMAwTcJ9G
+AAzDQKPRQKPR4KKLLpICdu+rtLR0fF5eXkZubu49ffW+aIqi1onF4s5h42EWi2UiwzC8Wq1m09PT
+FWq1GklJSRCJRAGvKQAA+wUZ8IwC9Jbg4GAEBwdjwoQJIgAiq9WK4uLiKK1We11ubu6lWq2Wslgs
+YBjmFDp5XGaz2USzLHv1mDFjkJmZKbxB0zQSEhIQGhrq7ePrFzzPw2AwwGAwwGazCa9znE+V6QkQ
+oM8458/SNA2ZTAaZTOZXoxzH6nNqaiqWLl2qAICGhgZotdoZ7VUfAACnT5/GyZMn7cPAmJgYTJni
+ExH1/cZqtaKxsRFGoxHNzc2IiIjA2LFjkZiYCJVKhaCgIARidwL4OwaDAS0tLdDpdCgpKcHZs2eR
+n58PR5HKkJAQiESi/n/REBMWFoawsDCX11paWjqM1XDAYDCgrq4Ozc3NmDp1Kq666irMmDEjkG8Y
+YMSg0+lw8OBBrF+/HkePHkVwcDAiIyMdyep+j98bK6vViurqajQ0NOCaa67B3Xff7ffD1wABLgSV
+SoUlS5ZgyZIlaGhowAcffID169cjLCxsWJTX8esIdoPBgIKCAkRERODrr7/G448/HjBUAQLAPpx6
+8skn8eWXXyI8PBz5+flwngfyR/zWWLW0tCA/Px8XX3wxVq9ejaSkJG93KUAAn2PUqFH44IMPsGjR
+IuTl5UGnG9Cg8iHFL42VyWRCSUkJrrjiCjzzzDN+OZEYIMBQwTAM/v73v2P58uUoKSmB2Wz2dpcu
+CL8zVjzPo7i4GOnp6fjzn//s7e4ECOA3PP7440hJSYFWq+1Vvp+v4XfGqq6uDkajMeBRBQjQRxiG
+wbPPPguDwYD6+npvd6fPkIA9w94RPGkwGHzaTWxsbMTMmTOdC9oHCBCgl2g0GkyfPh0NDb1OyRty
+zGaziz1yBHTTBEG0bNu2TbRt2zahMcdx4qCgIKNGo6FSU1OlarUacXFxXledsdls0Ov1mDt3rlf7
+ESCAPzN37lwcPHgQNpvN6+EMHMehsrISRUVFyM/PN+bn57MtLS1SkiRdPCaCIKw0z/PBzqko7dBN
+TU3phw8fnnPmzJklAGZYrdbomJgYo0ajkaemplKpqalDXs7F4fElJiZ68fQGCODfOFbOzWbzkBsr
+o9GI4uJiFBQUcAUFBfqioiKG53kjwzAnjUbjFo7j9gI4ynGcW5xFVz21wS4pftZoNP63/bXosrKy
+aRUVFdMOHjy4zGw2TxKLxWxiYqJtzJgxypSUFIwaNWpQD96R0zdcInIDBPAGjnSzwc6R5TgO1dXV
+KC0tRW5uriEvL49tamqSicXiIovFso1l2YOw1/vXWq3WHvfXF8tSDWAjx3EbDQbDMwBog8GQnpub
+O0er1S4hSXKG2WyOjYiI0I8ZM0Y2atQoWqPRBBR0AwQYIeh0OhQXF6OkpITLyclpKy4ulpEk2cYw
+zEm9Xv8TgH0ADhuNxguaFO+PGyR4X2az2eF9RdbU1Mysq6ubffDgwSVms3msRCJhIyIiTN3tqL6+
+PhB2HiCAj3Ls2DGUlpY2dtemvr5eYjQaabFYfNZisWy32Wz7ABxgWbamN15TbxjoMVstgA0cx20w
+GAxPAqD0ev04vV4f0cPnfhqEvgQIEKCfcByHtrY2c1tb2w09NK0HcMZgMNh6s98LYbANBAvgZG/O
+ySD3I0CAABcOB2C7tzvhd0GhAQIEGJkMlmcVhHY5LolEchHP81HdNeZ5XmSxWLx9LgIECNAJkiTB
+MIyEIIi8HtpVt8tw7QdwCAMswwUMjLEiAWQAmCkSiRZQFDXfYrEkhIeHt2VkZIg1Go3ESWTAI1u2
+bMGJEycG+tgCBAgwAIwZM4a45JJLUrtrU11dnVpQUDAzLy/PXFtbK5VIJJUcx+0ymUy/ADgAIBf9
+05q8IGPVWzmuoN7uUKFQDMIpDjAU8Dzf/seB5+GSIEsQhPAHwOsZEAEuDIVC0WMJpqSkJMyYMcNZ
+hiuhpKTklqKiomsHQoYL6J2xCshxjTA4jgPHcTAajWhpaUFjYyNKSorR0tKCtrY2GI0GGAxGmEwm
+mEz2f81mC1jWBudlapqmQVF2KS6ZTAqxWAKJRAKZTAaFQgG5XC7UxQ8ODkFYWBhUKhWkUikcUl4B
+/I/BkOEC7Mbqic4vkiSpEovFiywWy6R2OS5bRkaGMiUlhUhMTAzIcfk57dp+MBgMqKysRHV1Ferr
+61FfX4+6ujo0NjaiqakRBoMBAxUj01tEIpGg0hwVFY2YmBjExcUjPj4O0dExkMlkAQ/ND/Ekw1VS
+UhJVVFR0XV5e3orCwkJYLBZIpdJTRqNxm81mK+28DxrAiwkJCWxiYqIQHyGVSqnk5GRarVYHygTD
+ns9UUlKCiopy6HQ68DwPhUKBiIgIjBqVjKCgIJ+9gXieR1tbG4qLi6HVFkGr1aK8vAx1dXVeMUY9
+YbVa0dTUhKamJhQUFLi8xzAMIiIikJyshlqthkaTiuTkZMjl8oAX5meIRCLB+1q6dKkEsFdUKSws
+nK7VajNNJhPraFtaWkqXlZVRNABMmjSJWr58eUAp1wme53H+/Hls3rwJx44dhcFg8NiOoiiMGjUK
+CxYsxOLFF0Eul3u9383NTTh37pzwV1FR3i+j5JiHIkkKIoYBI5FALJZBLLUP7USMGLRIBIqiQdI0
+HGaDtdnAcSysVgusFgvMJqP9z2iAxWSE1WoBx3Hged5lbqsrLBYLKioqUFFRgb179wCwX/QJCYkY
+PToDY8eOx5gxo6FSBfm88eo8txcACA0NRWhoKKZNm0bDaYpq06ZNKCsrC0SNe8JoNGLNmtX45Zed
+PSZ7siyLwsJCFBYWYt26b3HDDTdi6dJloKihs/1WqxWFhQU4evQoTpw4Dq1WC5Zle/15vt1gUDQN
+qVyBkLBIhEXFIDQiBiHhkQiLiEbsKA0UyiCIGAYESdpvML5jgh3gPVaftN+IThPtRPtnOA4WswkG
+fSvadC3QNTWguaEOzY11aKyrRl1VOeprqmBo04HjWJAECXi4qa1WK4qKClFUVIjNmzeDpmmMGjUK
+kyZNRmZmJjSaVJ8o0mg2m3H+/HmcO3cWpaWlaGpqgsVigUgkQkhICNRqNSZMmAiNRjOk144/ETBW
+nTAYDPi//3seOTk5bu+5GC6e77hp22lpacF//5uN/fv34+GHHxnUJG6TyYQzZ87g4MHfcPz48Z6L
+qfEAx3MQS6SIjIlHVFwSQiOjERoRjdCIKIRGREMVEgaJVAYCBDiO9Wh8eJ4H3xdDKBgy9/dEjBhB
+jBhBIeGIS0pxeocARZHgARhadaitKkdVmRaVpUUoL8pHZWkhjAa9x6G3zWZDQUEBCgoK8O233yA0
+NBSTJ2dixoyZGD9+PCQSyaD9Jp6or6/H5s2bsGvXL2hubu6y3YEDv+GLLz5HUlISrrvuesycOctn
+pxa8RcBYOcHzPLKz/+NmqFLHTsakmQuQpMlAUGg4CIKEvk2HqlIt8s4cx4kDv8DQ1iq0P3PmNJ58
+8nE8+eRT0GhS+9qNLrFarTh9+hT27NmDY8eOdqtUwvM8SJJEdHwS1BkTkKQZjSRNBsKj40DRtOBN
+dYbrgyEaxF9C8AwlMjkSU9KRmJIOwB7+wHEc6msqUZx3DsV5Z1GYewq1lWXgOM5tSNXY2IgdO7Zj
+x47tUKmCMG3aNMyfvwBjx44dVA/GarXihx/WY926dTCZeieB5dAXePXVVzBz5iw89NBDkEoD6uEO
+AsbKiQMHDmDPnj3CtjIoFLc/8jeoM8a73dgyhRIR0XGYMH0uVt56H3Zv+R5bvv0EVou9+kVDQwOe
+e+5Z/PWvT2P06DEX3CeO41BaWoqdO3dg3769aGzsOvmd53mERcZgbOZMpI2fAnXGOMgVKrehrG8Y
+pAs/HwAQHhWL8KhYTJ13MUiShL5Vh8Lc08g7fRTnjh9CQ22lm+HS6VoEwxUZGYmFCxdh0aLFiIqK
+GtB5o5qaavz7368hL8896JvneSiDQhAaEQ2JTAaz0YiG2kq0tjQLfeB5Hr/9th9NTU145plnA/Xb
+2gkYq3ZYlsXatf8TjBJFi/DA315FZGxCj0ogFE1j0fLrMGnmAnz47+dQUZwPANDr9fjXv/6JF174
+JxIS+lbd1GKx4NChg9iy5Sfk5OR0O3eWpBmNiTPmY9yU2YiMS3AxRoNdYM0X4DgOUrkC46bMwrgp
+s3DdXRRqK8tx5thvOHnwVxTnnXP7TG1tLb7++it89906TJo0GZdeeikmTpwIiurfLVFQkI9//vMF
+NDU1Ca/xPI+I6HjMu+QqjJ86B6GR0SBAgOc5EAQJnudRXV6M/ds3Ye/PP4Dj7L9fbm4O3n//PTz8
+8KOBISECxkrg5MkTqKgoF7bnL7sK4VGxfdpHSHgkHnn+LXz4+t+Rc/wAAKC1tRUvvfQSXnzxpV5F
+6uv1emzfvg0//vgjamtrumhFIDl9HDJnL8KE6XMRFBIuXOD+7DUNFCzLIiwqBgsuvRqLLr8OuuYG
+nDiwG0f37kBxwTk4+1A2mw1HjhzG0aNHkJCQgMsvX4EFCxZALBb3+Xvz8/Px/PPPoa2tTXhNIpVj
+6TW3YN6yq4Rhp+tvZH+YRMYmYOVt92P6wkvw/j+fQJvObuz27NmD6dNnYM6cgO5AwFi1s2/fPuH/
+EqkM0xYsBcuyIPs4r0HRNO7+49/x35f/ivOnjgAAKirKkZ39Ph599LEun5BtbW3YvHkTfvzxR+h0
+LW7v8zyP6PhRmL5gGTLnLEZwWAT4dq/JYagCuMNxLBSqYMxdegXmXXIVGmoqcWTPDhzatQUNdVUu
+Q6/S0lL85z/v4uuvv8Ty5SuwbNmyXs8ZlZeX4YUX/uFiqGISknHd3Y8iPCqmV/NjPM8jNjEZ9/31
+Zbz+9IOwWc3geR6ff74W06fP8IlVTW8SMFawP4nPnDktbI+ZPBMkSYG1WSFimD7vjyBJ3PHoc3j9
+6QdQU1ECANi3by8yMzOxaNFil7Zmsxlbt27Bd999h5aWZrd9URSNybMXYe7SKzEqdbQwrONHwPBu
+oOE5DqER0Vh69Sosu+Z3OH/6KPZsXY+zRw/AOce2oaEBn3zyMTZs+AFXXbUSS5Ys7XbeqK2tDf/6
+1z/R0tLxkEnJmICr73gQFC2CTNE3YZWYhFFYftNdWP/JuwBBoLKyEkeOHMGsWbO8fQq9Cg0AW7du
+Ne/atUuoi8wwDNRqtUij0UhTUlJ8QoZrMGlt1QlzDDzPI0mTAcC+onOhC92MWIw7//h3vPLEPbBZ
+LeB5Hh9+uAYTJkxEWFgYOI7D4cOH8Omnn6CystLt8zK5CvMuWYl5y66EXKkCz/MjYv5pqOB5Hmnj
+MpE+YSqa6qqx68d1+G3HZmGBBACamprw0UcfYvPmTbjhhhuxYMECtzktjuPw1ltvuvyGSZoMXHPn
+H0CSJCQS9/Qgo74NjfU1iB+l6XI+dP4lV2HHD1+gtcV+Xe7fv2/YGiuHHFdhYSHy8/ONRUVFNpvN
+Jpw0k8kkAsDQAFIsFgs61ZOKbGhomHHmzJlFNpttNs/zwXFxcYaMjAx5SkoKnZycPOQyXINJU1Oz
+EOHN8zzComIAABazEUBw9x8mCOzc+DUoisK0+Ushk3fMS0VEx+HKW+7Dt2veAEEQaGtrw+rVH+CO
+O+7AmjWrcfjwYbeLVaEKwcVX3oTZFy8H3e72+6PUt7/AcxyCwyJx1S3345Jrb8XuLevx64/rYNR3
+hKLU1tbi7bffwk8//Yjbb78DY8aMFYaPGzduwOHDh4S2oRExuPbOhwUDJek0jCQIEmteexYF507g
+yVfXIDp+VBc9IzBl7kXYtflbAMC5c2fBcdywcBpaW1tRVFQErVbL5ebmGsvKyhiapnUikeiwXq//
+meO4AwDcJmxpiqKKPEwmFlkslgMEQbyZnp6OM2fORJeUlEwrKyubtmfPHo8yXElJSX47pjabO/Qs
+CAASqd3gsDYbLGYTGHHX/pXVbMKmLz4Az3FIHTMRNE27tJ80Yz6O7PkZJfn22K2DBw/g5MkTMBpd
+Y28kMjmWrrwFc5ddAZr2z/Po3/D2yfCVq7Do8uuwZ+t67PjhCxgNHXNQBQUFeOaZv2HevPm49dbb
+0NjYgM8/Xyu8z4gluP73j0LE2O8nnuch6nRvGQ2tKM4/C8A++d4d6vTxgrFqbm6GTqdDcHCwt09U
+n3DIcRUWFiI3N9eo1WptnuS40tPTtVqttt0bdb/fzGYzaJZlMWbMGGRmZgpv0DSNhIQE5yTmagAb
+2/+eycrKcshwTSkpKVkCYIF/y3C5xtjwfMdwq7W5yb7U7BSHw/M8LGYTWNYGkiChUAahtaUJ9TVV
+YMQShEREgaJo8DwPQ1srLr/hLvz3pb8Iw0EXQ0UQmHPxClx+411uT+EA3kHEMFi84nrMXXoFtq3/
+Ars2fwPWZve8OY7Dr7/uwvHjxyCVSoURCc/zWH7j3QgO7bjmPeU75p48As5mQ2RsAkIjo7tdvQ2N
+jBa8KZ7n0drq+8aqpaUFJSUlPcpxvfHGGx7luBoaGqDVal3ukdOnT+PkyZP2OauYmBhMmTKl1x3K
+zs4WZLgAfAoAWVlZkTU1NTPq6upmHzhwYLHFYpkokUhsarWajY2N7XbMqNVqvXqC5XIZCIKwp5IA
+MLS1QhkUAgBgWRuaG+oQFBKGPT//gOi4JKSNz4SuqaE9AZdEWGQM2nTNqKsuR3R8Ehpqq8GIJe3G
+iYOhTQdx+7YDnueRkJKBG+/5I+KS1IGhng/CiCW4/MY7MW/Zlfjhs/dx/LdfhPd0Op1LBsGkmQuQ
+PmGK6+/YPs/oGLoRBIEje7YDBIFJMxf0GGYiYsRw5CnxPA+bzTurvlqtFt999123bWpra40FBQUw
+GAyURCI5azabt9tstr0ADr733ns1vfsmICwsDGFhYS6vtbS0dBirgSA7O7sWHd4XsrKyKL1eP+70
+6dMzT58+HdzDx18A4LXszeDgEIhEIlgsFpAkgYbaKkTFdQRxWi1mnD12AN9/8i4IgsCo1DG46Iob
+ERWXCJ7nEBWXiJKCHNRWlAJT5wA8D4vJCIIgcOrwPmz55mO38ILlN/0eF624QUjsDeCj8DxUwaG4
+9Q9/xZylV+DbNW+huqzIJama53kkqNPcP0sQMOpbIVfai+a2NDUg58RBcByHqXMv7vGrjfpWEO2G
+rqvh0WDDcRzKysqsZWVlf+uhaQvs5YvP/Pvf/x4UOa5BC13Izs52yHD1KMWVlZX1PLxorORyOUJD
+Q1FdXQ2AQGVpEcZMnuHSJiI6DhNnzMfpw3tRUpCDNa89g8SUDCy56mbEJqYAPI/y4nwhdw0Adm3+
+Fvt3bHIZCkTEJODq2x9ERuencACfhud5qNPH4c8vvY9fNn2Ln77+CCxrvycJgsDGzz9Acd45XHLt
+bcLCCADoW3VgWRYMI8aODV8Kq81iiVQojdMVddUVLiWhvTgEtGVnZ7/krS934P9LCwMASZJITe1I
+OC7KOeW26kJSFJbfeBfueeKfyJgwDQRBoKzoPD7897M4f/ooeAA1FaUwtte9+umbj10MFc/zmDxr
+Ef78YjbSx2cGDJWfQhAkFq+4AY+/shrxyWnCMI0gCJw5uh8f/vtZNNXXunzGZNCjrqoc+7dtBM/z
+mLHwEphNRtRXV6ClsR6tLU1o0zW7lfUpL8oX/h8eHu4Vz8qXGDTPKisrKwjATJIkZ9M03W21eZqm
+6b7UXxoMJk2aLCQx19dWoa66AmGRMS5teJ5HaEQ0Vt52P2oqS7F9/RcoKchBzomDIAjCXtsq5wQK
+c87gzNF9Tk9NApffeBeWXHVTwEgNC3hERMfh0f97B1u/+x+2ff8/IUi3sa4aH/37OVx5y71IGT0R
+gN17+mXzt2BZG6LikpA6drKwJ4vZBJKkEBIeaa+G4Sh0SFHIOdkREpGamuqVIn0EQYCiKOahhx76
+uLt2NputuF2G62B2dnZL7/beNwbEWGVlZZEAxqBDjmseSZLxERERrRkZGdKwsLBuE62OHz+OkpKS
+wTi+XjNlylSIRCJYrVaQJIlj+3ZiycpVHtvyPI/ImASsuv8JnDq8Dz+v+wxWqxkEQeDHrz+GzWpx
+ct8p3PLQXzBp5oKAoRpmEASBS6+9FRkTpuDj15+HrtleU8xiMeGbNW9g4eXXYdbiy1BRUogTB34F
+AHCsDatf/RuM+lbYrFYQBAmaEUEkEkOuDELWk/+ETKFCTUUpaipKheto4sRJXjvGhIQEavLkybd1
+166hocGal5dnrqmpkT766KOVHMftdpLhysnOzu53RPMFGausrCwVgOntclwLaJqeKhKJCA9yXMG9
+2V99fb3XjVVQUBCmTJmCAwfsCcgnD+7GvEtWdhtOwPM8xk+djbikFHz+n5fQpmt2WfGjaRF+/8Q/
+kTp2UsBQDVN4nseo1DF4/JUP8PHr/0DBuePCe79s+hqNdTUoKzoPRzpPfU2l8DnwvD1qRk8I79XX
+VCFRocLBX7YIhkokErmEFg01CQkJWLZsWU/NRABELMuivLw8oaCgYFVRUdHVeXl5nF6vpx999FFn
+Ga4D2dnZdX3tR4/GKisri4JdxHSKVCpdAmABSZKxISEhptGjR4tTU1PpxMRExMb2rUKBL3LZZctx
+8ODB9mViK/Zt24CLrrixx8+FRkRh+vyl2Lnpa+E1yslQBRj+yORK3P/Xl/DD2v9i1+ZvhBirU4d2
+C23EEinSxk9BbKIayqAQiBhGyBu0Wa2QKZRI0mTAarHgwC+bhc9NmDARISH+IdxCURSSkpKQlJTU
+pQxXZWWl/MEHH2ylaXqf0WjcBuAogEPZ2dndyrLTAKZs3LgRGzdudH49jiTJ2WKxeDFFURMkEolN
+o9GwaWlpSrVaTSQmJoKmae8qIwwCY8eOxZgxY3D2rD3C+OjeHZg4Y36PpWIqiguw68d1HS8QBG5/
++BnBUFnMJjTWVaOmsgwNNZVoqq9BS1MjDK0tMBkNsFjM4NurXIoYMSRSGRSqYASFhiMsMhpRcUmI
+SUiGMjgEJBmozz0U2KwWGPVtaG6qh17XAqNBD6vFbK8HT1IQiRhIZDJI5UqogsMgV6rAiCW46pZ7
+ERWXiG/XvOkSrsKIJbjvry93ilrnERoR47J6yPM8ftu5GfpWnWDweuHV+DSdZbhsNhtKS0uDi4qK
+Li8oKLgoPz+fNxqN1GOPPXbGKT7LLWGWBnBELpebFQqFEFEqlUqh0WhkGo2GTk5ORnBwcN+L+/gh
+JEnid7+7BU8//VewLAuOY7FhbTZuf+TZrku76Jrx7YdvCRcmz/NYuvJ3sFrN+O7jd+zxV1XlMBsN
+femKGwRJIiQsEur0cUifMBVp4zOFwNUA/YPjODTWVqEo9zSKC3JQUVyIxtoqGPStvRq+2x8yDJRB
+oYiIiUdsohpT512Mg7s6hnIWswnffvg2brznj07GiQBrs7oYK5vVgp+/Xyt8LiEhAZMne28IOBjQ
+NA212i6ndvHFF0sAu/dVVFSUWVhYOCE/P/9ek6kjBa6trU2s1+vFNAAsXrxYvHz58hFhkHoiI2M0
+Fi5ciB07dgAAaivL8PN3n+HS6253u3B5jsO6j952yR8jCAK/bPwKNtvA6vHxHIfGumo01lXjyN7t
+EDFipI6dhGnzl2LM5BlCPlqA3sFxHCpLi3Dit104e+w31FaVX3DZHXv6lRkNtVVoqK1C7snDANwl
+tsq1efhmzZu44fePCnXS9G06iJ3mRXds/Bp6XbOwvXLlNaDp4V/JKTg4GJmZmcjMzKQBuGS8bNq0
+CRs3bgzUs/LE7bffidOnT6O21h4vc/y3XVAGhWLO0itc4mp2bPoaVWXuqULdGSqe50HTNKRSKZRK
+JWQyGcRiMUiSAsexMJstMBgM0OlaYDKZYLPZPC5ZWy1mnDt+EOeOH0RIWCTmLL0CMxdfBpk8IJbd
+HWaTEcd/24XfdmxCubbAJQ+0O7qWGesbJQXn8MP/3seVt9wLkqRgs1rRWFsNqUIJfWsLdqz/XGib
+lJSEefMCFUIdBIyVBxQKBR599I949tm/wWKxhyHs2fI9LGYTFi2/Dixrw+kj+3F498/d7ocgCISG
+hiI1NQ2pqXb14ISEBISHR0ChUICiKJfhJUmSEIvFYBgGIhENvd6AiooK5OScw8mTJ3H06BFotVq3
+ulZNDbXY9MVq/PrjOixafj3mLFkR8LQ6YTYZcWDnj/j1x3VobvS8EMXzPCiKQlhYGJKSRiEhIQHR
+0dEIDQ2FUqmCRCIRMhQsFgvMZjMMBj0aGxtRWVkBrVaL0tJSQbW7K2N2/vRRfPDy05gy9yKMnzoH
+kNgT5r/MfkV40BEEgVtvva3fNeGHE4Ez0QUZGRm4774H8Pbb7fNRBHDglx9RU1ECo6ENNRWlHj8n
+kUgxefJkzJw5C5MnT0ZsbCxop2A/BwRBQCQSQSwWC38Mw7gYL5UqCDExMZg6dSpuuaVD6WbHjh3Y
+tGkDjh8/7mK4WluasGFtNg7u2oKVt96PtHGTPQqDjiR4jsPJQ3uw+as1aKip8tgmJCQE06ZNx4wZ
+MzB27DhERESAoig31WSxWAyZTAaJRAKGYTyWKjYajSgrK8OpU6dw5MhhHDjwG4qLi90fMPU12L7+
+cxz85SfMWnw5eJ6HNu+sYODs18/wmqvqLwFj1Q0LFy6EyWTE6tUfgGVZEASB4nx3pRSCIDB+/Hhc
+dtlyzJ49GyqVyuVCd2j4SSQSSKVS4WLvayE1kiQxatQo3HXXXbjzzjtx/vx5fPbZp/juu3XQ6/VC
+u5qKEvz3pb9g1kWXY/lNd0MsGZlSTk0Ntfjuo3dw7vgBt4eFSCTCzJmzcPnly5GZmelWi83xm8lk
+Msjlckil0l7VUZdKpUhLS0NaWhquvfZasCyL4uJi/PzzVmzYsAHnzp116UtrSxN+/v5/ADqGlUql
+EnfccWdAVr4TAWPVA8uWXYKSkmJs2bLF7T2apjF//gLccMONSEvryLoXUiZIEnK5HAqFQhhCDBQE
+QSAjIwMvvPBPPPzww3jvvffw+edr4VhF4TgW+7ZtQHH+Odzy4F8QGZvg7VM5pJw5sh9fr3kdbZ3q
+2ovFYlx++XJcd931iImJ8TgXJZFIoFKpIJfL+/2bURSFlJQU3Hff/cjKuhenT5/Gp59+jI0bN3Up
+frpq1e8QERHh7VPocwQSmbuBZVl88cXn2LZtm8vrBEFg+vTpyM7+AM8886yLoQLsRiwsLAyJiYmI
+jIyETCYb1HK0kZFReO65v2PLlq1ughQVxQV4+++P4Pypo94+nUMCx7L46ZuP8fEbf3cxVCRJ4uKL
+l+CTTz7FQw/9AdHR0W7DPKVSiYSEBMTFxUGpVA74b0aSJCZOnIjXXnsdv/zyC2655VaPkl+bN2/y
+eo03XyRgrLrAYDDg1VdfxjfffO2SDR8eHoG///15vPjiy1CrXYvmOSZnExMTERwcPKjy5J5Qq1Pw
+0Ucf4+WXX4FS2bH6q2/V4cN/P4Nj+3d6+7QOKlaLBZ+//zK2fb/WZY4oJiYGL7/8Kv7616cRFRXt
+9jmFQoGEhARERkaCuQA1owshLi4eL7zwT2ze/BMWLFgI52q1ZWVl+MtfnsLevXsueP/DkYCx8kBb
+Wxv+8Y/nhTxBB/PmzceaNWswb958t/kEx1M5ODjYq3MNJEnixhtvwvr1PyA9PUN43Wqx4Iv/vILD
+u7f1Y+++i9lkxCdvPo9j+1wN8kUXXYwPPljjsRKuSCRCbGwsoqKivKYfkJaWhk8++RSvvvqqiwiL
+yWTEG2+8jg0bfgjklbZDA8ChQ4csJSUlQnCQVCql1Gq1ZCTIcHVGp9Ph//7veeTnd9QSomka9957
+L66++lo3Q0RRFCIiIiCX9y77yGw24/z58ygsLIDBYERISDDGj5+A+Pj4ATVyqampWLfuOzzwwP34
+9dddAOwlmr9e/ToYsRgTZ8z39qkeMKwWMz5543nktovKAvbf5Z57snDdddd7PK9BQUEIDQ3t07Vd
+W1uDvXv3IicnB83NzZDL5cjIyMDixRchMjLygvtPkiSuv/4GTJ8+A3/4w4M4ceIEAPs0xCeffAy9
+Xo8bb7xpWE+4cxyHiooKFBUVobCw0GQ0GoXhTE1NjSDFdX1NTQ1qalzKJMeeOnVqEcdxs1iWDYmL
+izOkp6fLHek3w0mGyxmj0YgXX/yXi6GSSqV45pnnMHPmTLf2EokEUVFRvYowLi8vx+rVH2Djxg2o
+q3ON86EoCjNnzsRf/vI0xo8fP2DHo1KpsHr1Gjz22KPYuHEDAIC1WfHF+68gODQCSamjvXWqBwyO
+Y/HNmjddDBXDMHjiiaewePFit/YkSSIiwh7n1ltyc3Pw1ltvYtu2bTCb3XUOpFIp7rzzLjzyyKMX
+JDvvYNSoUfjqq2/wxBOPY/3679uPj8M339il3royvP6ITqeDVqt1luMS0zTd4iTHVd75MzSAbzq/
+2P60edNms4FlWUGGa+/evcNOhssBx3F45523kZPTEZqgVCrxwgv/xPjxE9zaKxQKREZG9njxsCyL
+NWtW4/XX/+0SXtC5zb59+3DttVfjrbfeGdDEVbFYjNdffwM2mw0//fQjAHue2sdvPo+Hn38LwaH+
+veq07fu1OLKnY2jLMAyeffbvmD17tltbmqYRHR3da4PCsizeeedt7D9wAJdfeTUyxk/Gh//9Dxob
+6l3aGY1GvPvuOzh37iz++98PIBZfeEVPqVSKf//7dYSHh2P16g8A2FeXv/rqS4SEhGDJkqXePuV9
+prdyXAC0IpHIpTS4MzRgT5ZMTOwQSJBKpUhOToZarUZoaGhnGS7KYDBkDB8ZLjvr1n2L/fv3Cdsy
+mQwvvvgSxowZ69ZWpVIhPDy8R0NlsZjxxz8+hh9++AFAR0hDV58zGo14+OGH8MMPG1zmm/oLwzB4
+88230NjYgIMHDwIAWhrr8cV/XsE9T7wAyk91Cs8c3Y9t33ekp1AUhSeeeMqjoRKJRIiJien1Q9Vi
+seBPf/ojzp47h6/Wbxa0IKdMm47fXXcVPFW2/eWXX/Dqq/aJ/P5A0zSefvpvkEgkeOedtwHYb/jV
+qz9AVFQ0JkyY0K/9DzZdyXFRFHXMZDL9jC7kuBobG1FYWAitVgvnRObS0lKUlZXZjdWkSZOwfPny
+XnWkXQiiswxXRE1NzUxPMlwZGRnKkJCQbu/qzsOioebEieP46qsvhW2KovHss895NFRKpbJXMTAc
+x+Gpp57CDz/8AIZh8PAfH8e8hYuRe+4MXvzH39HY2ODxcwaDAS+88H/45JPPBtTll0gkeP/9/2Ll
+yqtQXGxfFs8/exy7Nn+Li668aahPeb9pbqjD1x+87lKG5Z57sjwO/Wia7pOh4nkezz//d6xf/z3u
+f+gRF9HacRMmISlZjaKCfI+f/fDDNbjtttsRHx/fr+MjSRJ/+tOf0draik8++RiA3YC++ebreOml
+V4bUGairq8PRo92HvjQ3NyM/P99UUFDAe5DjOvDee+/V9vQ9oaGhCA0NxbRp01xe37RpU4ex6i/t
+Vf88ynDl5+cvJklyVHef5zhuGjorjQ4Rzc3NePfdd4QnJUEA9913H6ZPn+HWViqV9jpY77vv1uHb
+b+0j7LvvfQC33X0vAECtSYNEIsFD9/6+S2O0e/dulJSUYNSoUb36rt4SFhaG9957D9dcc7UgIvnz
+92sxJnMmYhKSh+R8DwQcx2HdR2+hzak6waWXXobrrrverS1Jkn0yVACwa9cufPrpJwCAlk5BpazN
+BoO+rcvPWq1WrF//PR588KF+HydJknjmmWdQWVkhxPo1Njbi7bffwjPPPDtkoTFarZYrKSk50l0b
+juNK2ssY74ddjmvARRUGJYK9kwxXdk/ts7KyzACGJsDFCZ7n8cknH6O+vmMOYsmSpbj66mvcTxRN
+IyoqqlfejtFoxMsvvyQM+2bOmefy/pSp00HTIkHKqTMcx2Hfvn0DbqwAYNy48Xjiiafw7LN/A0EQ
+sFrMWPfR27j/6Vf9ZtX32P6dOHf8oLA9alQyHn74EY+/TURERJ9ip3iex2uvvSps//D9Olx7/U1I
+Gz0WPM/hs49Xo7qqqtt9HDhwYECMFQCIRAxef/0NrFx5lbDwc+rUSWzevBlXXHHFoJ5nwH4tmkwm
+c3Z29oz+761/+MfVOUicOnUKu3f/KmzHxsZ2e9H39km2Y8d2VDld0MXaQpf3KyrKe6x3df58zqAd
+92233YbZs+cI20W5p3HcTwJGDW2t2PT5B8KDgKZpPPXUXzxOmiuVyj6t+gFAfn4+Tp3qkLpsa23F
+TddeibtvvRHXX3kZXnvxhR73UV5ePqCxUSpVEN5++x0XKa6vvvqiXedy5DCouYHtclzTAQT30HTI
+jabVasXHH38krDoQBIE//vFPkMnc46VUKhVkMlmv971v3z4Xg/fO668hI2M0MsaMRW11Nf7xzF97
+9NBaW9t6+poLhqIovPDCP3HZZZcIE5lb132G8dPmuszP+CI7Nn4JXXOjsN05L9OBI+Wprxw75j43
+YzKZ8Nu+vb3eh8028ILEY8aMxaOPPoZ//eufAOxzm5988jEef/yJoQhnoLKysq7roU0z7HXUB0WG
+CxhAY+UkxzVDIpEsJghiLkmScZGRkYbIyMhujVF5eTnd3Nw8WMfokV9+2SlMNAPARRddhMxM9yhn
+RwpNX6isdC0fXVtTjRuvvgLhEZFoamyA1dpzFdHBvgA1Gg3uuONO/Oc/7wGwK6sc+nUr5i69clC/
+tz80N9Rh/7YOrYCYmFjccsutHtuGhYVd0JyO85TAhRIaGjIov99dd92NzZs34dSpUwCAQ4cO4vTp
+U5gwYeKAf5eDdiVoJj4+/qPu2tXW1nK1tbWyRx55pILn+b0mk2kngIMAzg2EDBfQD2PVLsc1oV2O
+a1k3clw9lq5cu3Yt9u7t/ZOrv5hMJnz//XfCtkwmwz333OuxbVhYWJ/nchjGfTKX4zjU1vTebQ8J
+Gfz66llZ9+Krr75EY6PdU/n1x28xY9GlEImGfPqwV/z647cwO1UquOeeezwO/6RSaZ+Hfw56m4nQ
+HQMZduIMwzB47rm/47rrrm3XCODw+eefY9y48YM63zhu3DisWrWqxxPTLsOVWFBQcHNRUdHKgZTh
+AnpprLqR4zKkp6eL09PTGX+S49q/f5/LeP+aa671uMonkUgu6KLv78Q4z/MehzYDTWhoKG677Q68
+/vprAICG2mqcObIPk2ctGvTv7ittumYccqrMqlarsWDBAo9tL2T45yAjI6PbKp89wfN8l/0aCKZO
+nYbLL1+ODRvssXt5eedx6tRJTJo0uZ977j/dyXDl5+dn5OTkXLAMF9CFsWqfa5pGkuR8qVQ6n6bp
+aQzDEImJibbRo0crNBoN0R617ncFvzmOw6ZNHUMJuVyOa6/1PBwPCbkwd37OnLl4//33L/iCJ0kS
+06ZNH5Lzceutt+K//31fiK7f9/MGTJ650OcqjB7Zsw1Gp5CBm29eBYJw9yYUCkW/Ul4mT85EWFiY
+4G32lbCwMCxefNGgnovHHnsMmzdvAsuy4HkeGzZswMSJk3wyFaezDFd7NHtwYWHh5bm5uYu1Wq2t
+ublZ/Oijj543m827WZb9FcDu7Ozsms77ogHwnXUDKYqyxcXFGdLS0pzluLx93ANCXt55FBcXC9uX
+XnqZx1xHiUTSp0l1Z2bPno24uDi3uaveMnr06EEJW/BEWFgYrrzyKnz++VoAQHF+DqorShAdPzTf
+3xs4lsXBXzqKH0ZFRWH+fM/eS3+vU4lEglWrfoe3336rz5/leR5ZWfde8HXTW9TqFFxyyaXYvHkT
+AOD06VMoKytFYmLSoH7vQECSJGJjYxEbG4t58+YJ3pdWqx1fUFAwOi8v75aKigpZVlaWmyNFA8CK
+FSs6R7C7yeEMF7Zt2+aS9rJy5UqP7YKCgi74OxhGjPvvfwBPP/3XC/r8LbfcOqQxTzffvApffPE5
+eJ4Hx7E4/tsuXHrd7UP2/T1RUpCDmsoyYfvSSy/zGOQplUr75VU5uO+++/HTTz+ioKCgT5+bNGky
+7rzzriE5J3feeZdgrGw2G3bu3IHbb79zSL57oAkODsbkyZMxefJkj3bHIcU1ouKsDAYDjhw5LGxP
+mjQJcXHuaRE0Tfd7ovXGG29ySxvoDRpNapfD0sFi3LhxSEtLF7ZPH9nnksbibY4f2AXA/oChKApL
+l3pO9O7PA8YZhUKBDz/8uE/ebUqKBtnZ/x0QY9kbMjMzMXbsOGF77969sFh6nPbxa0aUsTpz5jR0
+Oh0Au8t+ySWXegzeUyqV/R7/MwyDt99+t085YmKxGC+99PKQXfAOSJLEZZddJmzXVpShrqpiSPvQ
+FSzL4tyxjmj1MWPGIiYmxq0dTdMDOvwaNWoUfvhhA2688cZuU3VIksSKFVdg3brvhnSByV4ypuOh
+1tDQgHPnzg7Z93uDEWWsDh3quOilUilmzZrtsd2FLnt3JjY2Fl999U2valSJRCL8618vXZA3NhAs
+WbJE+D/Hscg7c8wr/ehMTXkxmuo75lrnz/dcNFChUAz4BHNISChefvlV7Nq1G88++xyuuOJKTJs2
+HVOnTsOll16KP/7xT9iyZSveeeddhIaGDvm5ufzyy11SiRwVNYYrI0bdhmVZnD59WtieNGmSm2QW
+AEG/b6BISEjAunXf46OPPsSaNatRU1PjdlONGTMGzz33vMcCf0NFenoGoqOjhZCOgnMnMG/ZVV7r
+j4O8M8ddfqOZM2d5bDdQDxhPJCQk4K677vb2qXAjKioaU6ZMxW+/7Qdgj77nOM5vcjz7yogxVpWV
+FS7RyTNmzPQ4BByMlRyJRIL77rsft99+B44fP4azZ8+itbUVQUFBmDhxEiZNmtSraqODiUgkwrRp
+04WKoqUFuWBtNlBe7ldR7inh/1FRUYiLi3NrQ9P0kAk9+BoXX3yxYKzq6upQWVnZ7/I0vsqIMVbn
+z593qT7YldrtYC47S6VSzJ49xyWJ2JeYMmWqYKx0LU1oaqhFeJT3An1tNivKiztW5MaPH+9xqCeV
+Sn0yxmgomDdvvuBN8TyPnJxzw9ZYDU9/0QPOddWDg4ORkOAu+kmS5JBPbvsSkyZNErxNnuNQVepd
+7TpdYwNam5uE7dGjx3hsJ5WOTMVpAEhJSXEpxHf+fK63uzRojBhjVVTUUaZFrU7xOOxiGGbEPqEB
+uyIO7VTiuLqi2Kv9qa4oEWp+cVzXKUjOpVNGGiKRCOPGdYQwFBYWebtLgwYNAAUFBdi6davwoqMG
++3CR4XLI/DhITU31WJB+JHtVgH2SOjo6GhUVdmGR+mrvhi/UVJQI/xeJaMTHu3vDFEV5fb7P24wd
+Ow67d+8GANTUVMNoNPqlt+m4T7VarVDJFoAQnEuTJLm6sLBQVFjY4XlQFBXOcdwMlmWD4uPjjenp
+6fKUlBTKX2W4GhsbXSSUkpI8pyWM1ElaBwRBIDExQTBWTfU9ls0eVGqrOtSYVCoVlEr3VFSapke0
+Nwy4Jl+bzWY0NDT4xbyVQ46rsLCQPX/+vL68vFxKUVQLSZIHWZZ1qdVDkqSV5jju954iX9vlcKKL
+i4unlZaWTtuzZ49HGa5Ro0b5/JOtvr5e8KQ4jvMYtQ7A549jKIiO7gi4bGms71cFgv7A87yLseyq
+Uqu/S8ANBMnJHfXzOY5DbW2NzxmrXspx7QZQ7EmbEWgfBsrlcpc4FalUCo1GA41GU52cnLwxODjY
+IcNFGwyGdH+T4XIOWSAIwqN6Ls/zgQsfcPntTEYDeI4DMUTCBM5wrA16J0GI0FDPZV8CDxj7A4ai
+KOGBXFfX/wKC/aUrOS6RSLTfYDD8DHtpGEGOq7m52aHGjPz8fBcprra2Nuj1eruxWrx4ca+kuLKz
+s21wl+GKbJfhmnXgwIGLLBbLBGcZLrVaTfQktDAYZWCd0ek6Kq2SJOlxKEsQxJCphfgyzufGajHD
+ZrOC8cJ5sVqtLoX2upp+CBgre3qYXK5Aa6s9layp6cLK23SFzWaDwWDo8n2e51FTU4OioiIUFBSY
+8vPzeaPR6JDj2maz2fahBzmu4OBgZGZmIjPTPaTIkcjc7186Ozu7FsCG9j9nGa5Z+fn5iwDMsdls
+PZW9HNSaGs4nuqscMpIkR/zcB+AaZ2azWe3Gygt12TmWhdnc8XTtKrF8OCwA9ReJRAK5XCYYK8e/
+A8WhQ4dw6NAhQ3dtaJpuArCvXY7rNwyCHNeAP5Y6yXC935vPDLYUl7Ox8sdVkqHE2VPhOR48NyDl
+s/sMx7HgnKTKuhqiB4yVfVTgLHRiNJr6sTdXOI4Dx3HG7Ozs/td77icj4pd2lvqmaZFHD4ogiIBn
+BbinIHnpnHAcD57r6EvAKHWN3Vh1PISHa6mYQR/wt5dI7qko9qDeEc43YFcX/UDqvPkzzso7JEV6
+0UjwIJy+2/mBE8Ad52DeQahFRmRlZal7aNMwmDJcwAAbKyc5rpkSiWQRQRDzSJKMlcvl+u4+ZzKZ
+RIM5ye58w3X3Q3prmd6XaGvrqHNOixjQtHdizwiCAO009HNeHXIm8JCx43weBvKUEAQBmqYlEonk
+eHft9Hq9/JFHHqnkeX5P+7zVAQygDBfQT2PVLsc1vV2Oa0E3clzdRpIOthSX83yH2Wz2eIHzPB8w
+VgCanXLxGEbitaoLBEFCLOkY2jgbUWc4L82p+RI8z8Ni6YhNEokG7jcjCAKzZs3CqlWrur2H22W4
+EjzJcDkJQey6UBkuoA/Gqjs5royMDHFaWprPynE5r3CZTCawLOsWptA+kTji50ZqazuuJZmi/xVT
+LxSCJCCVdcT+ORtRZwY77MVfcKgTAYDYC6u3vZDhuqU/MlxAN8ZqOMlxOQe8siyLtrY2t3rdBEHA
+arWO+LgdR6oNAISER3rPWBEEFEHBwnZ9fYNHzzdgrOzXtPOK92AWIuwLAynDBdhzA49v375dvn37
+duFFnueDKIoKHS5yXMHBHWFeHMehubnZo7iA1Wod0aENNpsN5eUdxio0ItqLvSEQFNIRTd/QUA+r
+1QKGcU02H64rX31Br9e7DJN9NX+3tzJcDz/8cCNBEC2dPqunOY6bNG3aNMydO1d4g6ZpREdHg6Io
+3zzqPuKcQkIQBKqrqzwmM3eVkzRSaGhoQENDg+C9RMYm9HOPFw4BIDQiStg2GAyoq6t3qxRqtVpH
+/PC9paXFZQHCG/XgL5TOMlwsy6K6ujrSZrMJOXF79+7F7t277cPAoKCgLisRDAciIiIcidkgCALl
+5eWYMcO93Ug3VmfOnHHZjkkY5bW+8DyPsMhYe5xX++JHcbHWzVhxHAer1Tqiy/uUlpYKBpsgCERE
+RHi7SxcMRVFuv7FDO2FEPI4UCoWLa+ysyOyMxWIZ0fE8J04cF7wqWsQgKm6U1/rCcSxCI6IgEtlD
+JwiCwPnz5z227SqsYaRQWFggeJYEQSAqypvD98FjxMwmJyYmobm5GYC9mJfD03KG53mYTKZ+C5z6
+K4cPdwjARkTHQq7s3SwASVEw6ttQW1WGxtpq6Nt0AM9DplAhNCIa4dGxUCiDwfFcr4OAeI6HRCpH
+SHgUaitLAdh1Hz1hNBoHTODUH3E24kqlctieixFjrNRqNU6dOgkAKCkphtFo9Dh0MBgMI9JYtba2
+CucHAEalju12JZAgCFSVFePY/l9w9uh+1FSUwGazgiA6EsLtsWscSJJCaEQ0UsdNxoRpc5ExYapL
+dLonHHFv8cmpgrHKzc2FyWRyK2NsNBpH9LzV2bMdw/eEhIRhu6I9PI/KA6mpqcL/DQYDtFotMjIy
+3NoZDIYRGRx65MhhlxWltPGe1X8IgkBJQS42fv4BCnNOurxHkpRbW4Kwv9ZYV42Dv/yEAzt/RGhE
+FC69/k5MnXtRNz2ye2BJmgwc27cDgP23OXv2LKZMmeLSkuM4mEymQVUm8lX0er2LZ6VWp3i7S4PG
+iHkUaTSpQiAoQRA4ftyz4rDNZhuRcyBbtmwR/s+IJVBneFaR3vTlh3jjbw+5GSoHDo/I8dcZgiDQ
+VF+Lte/+C5+9+2LXw8L2h0WiOl2IoicIAnv37vHYvKsI9+HOuXNnXQJC09Mz+rE332bEGKvw8HDE
+xHSU7D106GCX3lNra6u3uzukmEwm/Pzzz8L2qLSxUKqCXdoQBIHvPn4X29evhcPrcSASiRAcHIyY
+6Bikp6Yhc9IkTJ86FZMnTkR6Whri4+LcAhUJgsDxfTuw8csPPf4OjiGdTKFCbGJHDu2+fXtdkq0d
+6PX6EZl6s3v3buFckSTpcbQwXBgxxookSUycOFHYPnfuHJqaPKdwjLQLf8eO7Who6CiFO3nmArfS
+MHlnjmPP1u9dDItSocCoxCSkJKsRGx2DpMQEREZGQC6XQywWQ6FQICI8HGKxGOpRozBj2jQkxMe7
+7OPXzd9A5yGVhmqvIsDzPDImTBNer6urw/Hj7jm1HMe5eBgjAZ7n8csvvwjbiYmJCAnpqc6l/0IC
+LvWSUVJSgsrKymF5s06ZMlX4v8Viwf79+zy24zhuxHhXPM/js88+FbYlUhnGTXNVjCYIAnt//sHF
+yMTFxiEuNk6Y7FYqFV1O7JaVl+PUmTOoq6tDUmIixo3pECvlOBb5Z92H5I6QBQBInzjVJaF68+aN
+Hr+npWVQK5T4HGVlZS6T65MmTfb7uVaO41BZWelijxy/K02S5InDhw/LnZetOY4LYVk2KC4uzpiR
+keHXMlzOjB49BkFBQcLBb9u2DZdfvtzj3EpLSwtUKpXf//g9cebMGfz222/C9oTp8yBXuP7OJEWh
+rKhjEjckJARKp2EdQRDdim1MzcxE7vnzKCouRlhYGIKCgkBRlBDTZvQw30TRtBBeolAGIyVjAvLO
+2I3agQMHUF1djeho13gis9kMg8EwYibaN2/e5BIXOGPGTG93qc84y3Hl5ubqKyoqHHJcLu62I91m
+srOgoBPRJSUl08rKyrqU4WpPZPb28fYaiUSC6dNnYNs2+/zMyZMnUF1d5TGIzmq1QqfTDduYFQf/
++c97grEmSBJzllzhsZ1rcbe+ed0kSUKTkoJDR46gvqEBKpUKNpYVKi6eO3EQmrGTEB2f1NEXgoCI
+YWBuX+yYPHsR8s4eB3geFosF69d/j3vvvc/tuxobGyGVSof9Q4ZlWaxf/72wHRUVhZQU314J7K0c
+l81mK/b0eY9+e3vIe3VaWtpGjUazMTk5+ZknnniCMhgMGf4mw9WZRYsWYfv2bcJq1caNG3H33b/3
+2LapqQlyuXzYxq2cO3cWW7b8JGxrRk9AfHKqWzuWZRESEYX6mkoAdq8zJChYGALyPA+z2dxtygvD
+MAgLC4NEIkFxcbFLadicE4eQc/IwZl+8Alf+LksYAjISqWCsRqWOQWR0PGqrygAAGzduwE033ez2
+MDGbzWhtbfX7UUBPnDx5Ajk5OcL2nDlzfc5x6K0c13PPPWfWarUoKChAXl4eKioqPGaS0ACwYsWK
+HqW42oUgOstwBdXU1Eyrq6ubf+jQoflms1koI+MovqfRaHzqJKanZyA+Ph5lZfaL/scfN+OWW271
+eKOxLIv6+nq34cZwgOd5vPLKK0KJFYIgsPiKG908ErPZhE/ffAF5p4+5vFdWUY6khERBxbqtTQ+a
+pruVMxuTkYHSsjK06HSeOoT92zag8Nwp3PvUiwgKDYNYLEFre24gQZCYvvASbPriAwD2mKu1a/+H
+++9/wG1XDQ0NkEqlPnXdDTSffvqJ8H+aprFw4UKv9ofjOJSVlaGgoABFRUVGR/kXsVjsXP7l167k
+uNqTmT3ue0CkuNprLm9v/0NWVhZls9nG5ebmziouLl60ffv22RaLJUapVHYbuGQ0GocsZJwkSSxb
+dglWr7Zf9E1Njfj5561YscLz8Eev16OlpWXYDQd37tyJnTt3CNuasZOQNtb1YjEZDXj774+hqrTQ
+zYixLIvi0hLERsdAoVCA53k0N7dAoVBALPZcCrm0rAwlpaXCtkwqQUJsNHILtML+ayqK8cYzD+GR
+599CUGg4GEYMS7sk1+hJ07F/+wY01tnLHf3ww3qsWHEFEhJcq0PYVYlrERsbOyyHgzU1Ndi8ebOw
+PWbMWMTHD16FjAMHDuDkyZPdLrW2trZKGIapArDfWY7r9ddfH7Bk2wEd33iS4crKygppaWnpaT01
+F8CQPQYXLFiIr7/+ul38lMCXX36JZcuWudVKctDQ0ACGYYZNrSu9vg3PPvs3YX6IpChcdv0dnQQa
+bMh+6S+oKi0UXqNpCsFBKtQ32Oc+OY5DeWUFFHI5wkLDIJVK0draCqORhkwmFbyuFp0OJSUl0HVa
+Yf3D3aswc+pEHD5xBu99+CWaWuweV0tjHd574XE89sK7kMrlgrGiKBpzl16FDWuzAdhXdN9++028
+9NIrbkbJZDKhvr7erysQdMWaNatdKoRceumlg2aUOY6DxWIxWSyWCT00bXrzzTeberXTC2TQJ2Oy
+s7ObAHR7EFlZWUNa9V+hUGDp0qX49ttvAACVlRXYvHkzVq682mN7nudRXV2N2NjYYVGK5MUX/4VS
+Jw9n2rwlSNKMFrYJgsD6T/+DkryzwmtKhQw3XnUZglQKfLvxZ2jLKoV5pza9Hm16+zBQKpEIk/Es
+x8JkMnkskHf3qqsxc+pE8DyPqRPH4s0XnsSzL78LbWkFAKCuqgyf/+dl3PHosy4rhxkTp+Povh2o
+KC4AYE++3rJlCy699FK379DpdKBpeljFHlVXV+N///tM2I6Li8fUqdP6scdewWdnZxd5+9hHTFBo
+Z5YvX+4SVf3pp590m7LBcRyqqqr8vjLl1q1b8dlnHRe7KiQMy2+626VN3pnj2PvzBmFbJpXiluuu
+QFhoMGiaxg1XXYpZU9wftDabDa1tbWhqbkJTcxN0Op3b+RLRNB7NuhXLly50CRlRKuR44S8PIz6m
+o+DeqUN7cOLAbkgVHZWzSZLEkpW/c1mdfPfdt1FVVenxeBsbG4dV/NUbb7zucp2uXLly2C4AdWbA
+j9KTHJfVau1WN5CmaWaog1CDgoKRkJAgrKg0Nzfj448/woMPPtTlZ1iWRVVVFWJiYoQhjj9RVFSE
+xx//kxB6QJAkVt72AOTKjvk4nufx7YdvCQHsJEnguiuWQqV0jataNHc6RqelYNe+Q4I31BMTx6bj
+vttvQFREmMfYNqlEjL8+eg8e+dtLMJstIAgCG9Zm469vfAKjngbbvhgQHZeE6Qsvwf7t9uBQvV6P
+559/Hm+88aZHz7e+vh48z/ttWW4Hp0+fxtdffyVsJyYmYv78BYP6nSRJgiRJ6QMPPNDtnJVIJGoY
+TBkuYACMVVZWVhiAmSRJzhKLxYspiprEMAyvVqttGRkZSrVaTcTExHQ7pv7mm29w4MCBgTyuXtHS
+4roq9cMP67FkyZJuk0FtNhsqKysRHR3tVqrEl2lubsbdd9/pkmI0Y8EyTJg216Xdsf2/oLayVPi9
+Zk+bjJgo93kfngeiIsJw48rL0NjUgtz8IhSXV6K+oQlmiwU8DzAiESLCQzAmLQWL5kxHWkrP1Wij
+I8Nxy7XLsXrtd/Z+19fg2P5fMH7qHOiaGoV2sy9egaLcU6guLwEA5Obm4N//fg1PPvmUx2utocEu
+OOGvQ0KWZfHcc88Iq7ckSeLmm1cNyYrn9OnTcd1113UZacvzPKqqqmRarfbm8+fPX11YWMhbLBbi
+T3/60xmj0bjNZrPtA3AgOzu7oT/96JOx6kaOyzR69GhxamoqfSFyXN5wY202G/T6NrfXXnnlZbzz
+znvdGiKHhxUVFeUX0dIGgwH33PN7FBQUCK/FJ6fiylvuc7mxCZLErz9+K7wml0kxe9qkbvfN8zyC
+g5RYMGcalsvlkEjEoCkSIhENmVQKiZgBSZJ9EiO97OL5+P7HnWhoagYIAr9t34QZC5bBZNDD0j6x
+TNMirLj5Hnz61gswm+zKLj//vBWxsbG47bbbPe63sbERLMsiLCzM71YJP/vsU5fiiBMnTsK0adOH
+5Ltpmu7xOtdoNNBoNFiyZIkEEGS4phYUFGSeO3fOUFlZKXnwwQfbKIrabzKZHDFWvZbhAnowVn2Q
+4/K7anVmsxmeIvcLCwuRnf0+Hn74kW4/74jGDQ8P9+kARKPRiPvvvw8HDnSk1CiDQ3HrH552EREF
+gNrKMpQVnhdWBadPHt9jQbvgICUSYqMhk3Zt3PuqmkwQBC67eB4++8Y+zCvOP4c2XQuUQSForKsR
+9hcWGYvLbrgTP3z2H0Fp+5NPPkZQUBCuumqlx323tLTAZrMhMjLSb4r15eWdx0svvShsSyQS3Hnn
+XT7dfycZLvLqq69WOMlwXZabm7uorzJcgD038IOtW7eKtm7d2vEiTYdyHDedoqiw4SLH1Rm9vk1Y
+YeJ5HhRNg2vf/uGH9Zg4cSIWLlzU7T54nkddXR3MZjPCw8N97mnd2tqKrKx7XGpAiSVS3PaHpxEe
+5e79njm63yV8YcKYtG73nxgfg5jIwclYmDsjEx9/uR4URdnFIvLPYczkGVAGBbtUaUgfPwXzLlmJ
+X39cB8CelfD222+B5/kuV3f1ej0qKioQHR3t84GjbW1teOihB10qSkyfPgPx8fHe7lqf6IMMVwNJ
+kodsNltjp89baY7j7k5JScHo0R1L12KxGMnJyYiPjx82clydaW1tFYwVx3FYfu1t+PGbj8FzHHie
+x8svv4T4+ARoNJoe96XT6WA2mxEVFeUzF39VVRXuuedunDzZUSRPxIjxuwf/4rGwHkEQ0OZ2ZPDH
+xURCJpN26RVFhIcOmqEC7PNhKqUCeoMRBEGgrqocmDwDEpkcVosFRkPHzTtr8WVo0zXh6F57kCvH
+cXj77beg1+uxatXvPD5ELBYLysvLERkZ6bNlrDmOw1//+pRLWg2AYSNq4kmGq7y8PEqr1a5wjiPL
+yclBTk6OfRio0WiwbNkyb/d9SHEuAUMSBGZedDl0LU3Ys8WeHGo0GvGXvzyFt956C9HRMT3uz2w2
+o7y8HKGhoV6v1nDw4EH84Q8PoqqqSnjNbqiewthMz5n5BEmiqkwrbMfFRHVpqAiCQFJcz+ekP5Ak
+CaVCDr3BPlQ3GZ0Uh4OCYbPZYLU4LmgCF195M1ibDScO/ArA7vWuWbMa1dXV+MMfHva4eusYygcF
+BSE0NNTnhlXvvvsOvv/+e7fXO8+1DhecJeidsVqtyMnJGblxVs3NHbE3NMNAIpFh+Y13QzOmo0Bf
+XV0t/vznP6OxsbFX++Q4DvX19V6Lx7JarXj33Xdw8803uhgqqUyBOx97DuOnzunyszzHQd/acU6C
+Vcou20rEDGi66xzAgYDnOcFQAQDjFJJAEASCQsNcalwRBIll19yKzDmLXfazefMmPPLIH1BZWdnl
+d7W0tKCiosKnylmvXfs/vPbaqx7fGym11jozYo1VW1vHDy4WS0EzDEQMg1se+isiYzryrMrLy/Cn
+Pz2Gxsber7oajUaUl5ejvr5+yFz23Nwc3Hjj9XjppRddyv6GRkTjvr++jPQJU7v9PM/zLqVfuvMy
+jCYzSsurYDKZwXFdeV/ol3dZVlGNFl2r0LeIaNc5GpIkERwW4Wawllz1O8xZcoXLd+fk5CAr6/fY
+suWnLsvbWCwWVFZWoq6uzuvDrO++W4e//e1pl76GRnYk04/UevMjI/TVAzqnzH+ZQgmCIMADUAaF
+4K4//wPv/d+f0NJoL/Wr1Wrx8MN/wD//+aJb0mxX8DyPlpYWoVxJUFDQoIRoNDU14d1338HHH3/k
+5s2ljp2EVQ88BVVwz3LiJElBplAKeXhNzbpu21fW1KGiuhYESYBsl98iAIAA2vQGtLS0wmS2QCSi
+ERYSjCCVAhFhIYgMD4OYEYHtJgiYIAj879tNTrXFKReP1wFFUQgJi0BzYz1s7QaaIAjMW7YSoRHR
+2LruU+F42tra8NJLL2L79u146KGHkJQ0yuNvptPpoNfrERwcDJVKNeRDw6+++hJPPfWkEE8FAHOX
+Xonw6His//RdAGh/SIw86bERa6ycV1fkCpWLykpEdBzu/vP/4b8vPoXWFvvKU3l5OR5++CE899zf
+MWHCxF5/D8dxaG5uRktLi6AMLRaL+z2npdO14NNPP8Xq1avdvD6aFmHxFTfi4qtucklL6Q6e5xCf
+nIbmhjoAQE5+IRbOmdajdiABAmaLBYXaUuQVlaCkrBJtegN4wKVmFc/bjYFEzEA9KgGTxmVgwpg0
+pKoTIREz4DgeBACrjcX/vt2I346cFL57wvR5kMoVHufQSIpCcFgEWhrrYXUy1mMzZyEsKhYb12aj
+obZjSHz06BHcc8/vcfnlK7Bq1c0IC3NfJGBZFg0NDUK1DaVS2W3pm4GA4zi8++47eO21V108qokz
+5uHK390rzMUB9rI9NpvNL7Mo+sOINVatrR2eg1wV5KYIFZeUgnue/BdWv/w0WprsHlZTUxP+9Kc/
+4oYbbsTNN6/qUxUGnufR2tqK1tZWiEQiyOVyyGQyiMXiPj0htVotvvzyc3z11Vce59LiklJw7V0P
+uyQm97Z/46fMxpkj9rr0ulY9ft61D8sWze3yM8VllTh19jzyiophtdoE4yJ4WU4Q7W6X1WbD+QIt
+zhdo8cV3P0IsFiEuOhIRYaGwsSwKtKXQteqFfVEUjctvvKvbWC3HkLC1pRkmp1XC6Lgk3Prw37Br
+8zc4eeBXwQhYLBZ8//06bN36Ey6//HKsXHkNYmNj3b7DZrOhoaEBTU1NUCgUUCqVA/Kg6UxjYyOe
+eeZpbNiwweX10ZOm4/q7HwNF04KxJggCVqsVFoslYKxGCs6TlDKFCjzvPiyJS0rB/X97FWte+ZtQ
+odJqteJ///sM27b9jFWrfoclS5ZAIulb6Rir1Yrm5mY0NzeDJEkwDAOGYSASiSASiRz5WEL7xsZG
+7N69Gxs2rMeBAwc8SlHJlSpcdMVNmLP0Chexhb4wadYCbP7qQ+ia7Z7a8dO5qK1rxLTM8YiLjgRF
+kWjRtaFAW4pT5/Kga21zMVCdcZ4HIwjCzSiTJAGr1YbiskoUl3VMgDvvasXNv0d4VM8rjwRBQBUc
+AhHDoK2lWTA8YrEUy66+FRkTp2H7+s/tIRDtGAwGfPPNN1i/fj1mzJiJ5cuXIzNzilv4Ccdx0Ol0
+0Ol0EIlEkMlkwoOmrx4Xx3FgWRY2mw1GoxGbNm3EW2+9hdpa11jIiTPm46pb7oNUbs/JtP9r91cd
+lVk7y5sNd0assTIYOpbCZfKuV74iouPwwDOv4fP/vIzzp44Ir9fU1ODf/34Na9asxoIFC7Fw4SKM
+GTMGEomkTxHbDjVhx0oUQRAwmUzQarU4efIEDh06hLNnz7jUL3JGIpVh5qLLsGjF9VAG9S/vTcSI
+cfXtD+KTN/8hGO+K6lqUb94uPNV53m5kHH11wPM8KIqCRqOB2WxGSUkJFixYiCVLloJlbdDpdKiu
+rkZpaSlOnz6NlpbmbvvCSKRYfsNdmDy7+8DczkhlcohEDFpbmlyGhUkpo3H7w8/i5KFfsX/7JrTp
+Or7farVi79492Lt3D0JDwzB79mzMnTsX48aNFwoLOrdtaWlBS0sLCIIATdNgGEaokkqSZPt5shtq
+juNgs9kEA+UoDLhz5w788MMPqKgod+k/SZKYffEVuOiKGxAUGuZyXPbfwH6uDQY9wsK6rQ8w7BiR
+xsquMddhrBxPr65QBoXg7j//A/t+3oAt6z51GWq0tLRgw4YfsGHDD1AoFEhNTcPo0aMxalQy4uJi
+ERoaBqVSCbpdrcVR+51lWej1bWhpaUFtbR0qKytQWlqKgoIClJaW9KiBpwwOxYyFl2DOkhUIChm4
+4Mwxk6dj5W0PYMPabNis9pvdLgPvMFCu7QmCQFpaGmbPnovMzEzI5XJ89906lJSUQCqVCsKyISEh
+SE1NhUqlwvvv/wcvvvgvAHYVm+j4UdC36kASBIJCwzEqbSwmzVwAqVwBmULZ+863Q4tECA6LgEHf
+CkNrq2BsKJpG5uyLMDZzNk4c+AVH9mwX5iQdNDY2YNOmjdi0aSOkUik0Gg3Gj5+AjIwMJCerERER
+4VJ73mq1evR0HeeG53m0tbWhuFiLU6dO4fDhQzh79hysVvfQFoUqGMuuuRXjp81pf/B0nGyJVC4c
+B8/zMBp9J8xiqKABYOPGjdi4sUOLjaZpq0OGS61WU2q12qfz3/qK48nkQNqLCGaKojH/0qsxftoc
+bPv+cxzbv1NYaXLQ1taG48ePCdL0PM+DJElQFAWRSCQMGViWhdVqFZ68Dq+lxz7QIiSnjcX0BUsx
+buocSKQDn0RNixhMnDEPkbEJ2LX5G5w/dRQcxwr969zXVatuwaJFi4QbieM4IenVscQeGRmJiRMn
+Cp9zjmeSyZW445FnwbIdq1+O8xYcFnHB80MEQUCuUEEikaGttQVmpzxQsUSKGQsvQ+aci5F78hCO
+7/8FVeXF4DutUBqNRpw+fRqnT58W+iSVShEWFoaIiEiEhYVBqVRBJrPXeycIAjabFQaDETqdDnV1
+daiurkJ9fQOsVjMAz8dC0TQmTJuLeZdcjYjoOMiV7vea/bcmXPo2XNDpdCgqKkJRUZEgx2Wz2dxW
+hmhPZ9BmswkyXGKx+GKz2TxFIpH4tQyXMyzLuizzS2W9H/uHhEfh+t8/iotX3oyDv/yEY/t2orGu
+2uPQz/FktdlsLkvRntp1hVgiQ5ImA2MyZ2Jc5iyEREQNenS8QhWM8MgYrLz1fhgNelQUF6CpvhYc
+x0KmUGHzV2uEG7vzsJcgCCFvrbnZPjE9fvx4lz4bnII9RQwjGGzAvronlcogV6hc8hQvFIqmERQS
+BqvcDH2rTqjaANiFVMdPnYvxU+eitqoM544fQN7po2iqr3X7PR2/pcFggMFgEARHeo/7byaWSDF6
+0nRMm78METHxUAYFuyWXO58n5zk/k8k/jVVXclwMwxRYrdYdDjkuAMWdP0uTJOlWsIzn+Wqr1box
+Li5uY1pa2jPbt2/vUoZr9OjRsuTkZL+Q4XJgsVgEY8XzfJ+MlYPQ8Chcet3tWLpyFcqLC5Bz4jAK
+c06hulwLg77N7SndG2haBGVwKKLjEpGQkgF1+ljEJ6dd0FCoPxAEgeBweziARCpDymjXqqA/fvUh
+Om5lp//xfPu8nRgcx6OhoRHjxo1zm4R2ThcRS2TgeQ4kSUEVEgpGPDg1wkSMGMFhEbBazDC0tcFs
+Njp3HZExCYiMScCCS69FfU0FtOfPoKQgB1VlWhj1bX2uHNEVYokUcaM0SB8/BWnjMiFTqCCWSqFQ
+BYEku56sp2gRaJruEIb1k2Fgb+W45s6da3bIcDm8VGfMZjNojuMwbdo0zJ3bsURN0zSio6OFi+y6
+667rVobr8OHDfiHD5cBqtbp4OhLZhSeyUrQISZrRQqiA1WJGU0MtGmqr0VhbjdbmRrS1tsBqMbeX
+MbGvitEiBjKFEsqgYKiCwxAaEYWQ8CjIFEpQlPenEkmSQkh4FKwWC0xGPcxGgxCISFKUUJLF2UOV
+y+WIj4+H2WwCQdizBDzVBauvrxf+71jcCA6P6HVMWH8QMWIEhYrB2mwwGvQwGQ1CtQ3AbqgjouMR
+ER2P6QsvBWezoamhFrVVZaivrkBjbTWaG+ugb22ByagHa2PB85xg94j2fZCUPdxAGRSC0IhoRMbE
+IyZBjcjYBMEgM2Ix5EoVREzPdf0d1wzL2j0qs9n3jFV7IvIFy3E59lFdXe1yf+7duxe7d++2z1kF
+BQW5JQ/2RBcyXGOdZLjmWCyWmOjoaH14eHi367vl5eVDmvZuNBo7npQ8D2k/jFVnRIxYeEoPB0Tt
+aUgKVTBaW5pgMZsgFkuEyXfn1A+Hkkx4eAQoioJer0dbWxtCQ10j6J3rpSuCgiGRyobEUDlD0TQU
+qiDIlSpYLWaYjAZYTCbXdByeB0lRCIuMQVhkDNAeC0wQBDiOta/wWS2wWizgWBY8eJAk1X7OxO2r
+g5TbMJmRSCCTK3plpDo+R0LEiGE2OYyVudef7S9nzpzBu+++2+2KT319PVtdXS1vl+Pa5yTHdbYv
+clztAssur50+fRrAAK4GtstwnWr/ywbsMlyVlZUzKysre7pz3x3IvvSE0SmDHwQB8SBMVA837HFM
+oWhprIciKAT6NntQbUNDR/S8o9SKQqGAXC5Hc3MzGhsbXYwVz/MoKuqo7hAcGjHkw9zOx8WIJWDE
+9rk3q8UCi9kEi9kM1mb1OPzj20VXaZoETYsgkXb9sON5HgRJQsQwEEukEEsk3Q73uu4oXIbIQ5V0
+zXEcGhsbrY2NjY/10LQMwIHBlOMaVAPRLsP1U0/tsrKy3h7MfnTGeYIXQJeTmgHckauCEB4di5oK
+e+1zrbYIJGkfFjpyHymKglKpRHNzs0sOJgCUlZWhpaVZKKo3Km0MqCH2qrrCbrjEQoUHjuNgs1ph
+s1nAWm2wsTa7B9W+INDZYwJhz5MkaQoURUMkEoEWMaA9zMH0FZ7jIfaCsWrHlp2d/d+h/EJPeH9y
+xAs4r6Q4nqwBegdNi5CcNg5nj9rLJJeUlKCpqRFBQUGu84ASqRDg6syvv+4S5kI5joNmzCRvH1KX
+kCTpYrwc2I0U75Ki5UgnGqyVWp7nwTjN/w3lMNBXGBRj1S4s4ZDjWsAwTFR37WUyGT2UTwrn7yIp
+qk9zBwGASTPmY+PabBDt0drr1n2Lu+6622X+ytPwiWVZfPHF58J2TPwoKINDXCa4/QG7QSIwyBEk
+neAhYjqMVVeBqAMNSZKQSCTiP//5z9u6a2exWGpMJtOv6JDhGvAfdUCMVSc5rosoipokFotZtVrN
+pqenK8PCwrr9Wffs2YPz588P9LF1iUucT3uw5kAtTY8EwqJjkTZ+CvLPHgcA7Nu3FxKJBDfddDPS
+09MB2BPFeZ6HUqm0y8yXl+PNN9/A6dOnBe9j6ryL/c5QeQue58E4PVSHsrhjUlISOW/evIu7a9PY
+2Ii8vLxrCgsLeZPJRD722GNnzGbzzwMlwwVcgLHqSo7LOeaqr3Jcubm5Q2qsLJYOF5oWiUEQJHg+
+cNP0Fp7jsOLm3+ONvz0kRLfv3LkDv/66C2PHjkVMTCwaGxtBkiQeffQRNDU1CkKjDkMllSsxd9mV
+3j4Uv4J2qrIwlMYqIiICU6ZM6bFdJxmuKSUlJZMdsVX9leECemGssrKyogBMJ0lyWmc5rk7R7H6T
+j+M8DBQxA1/yYyQQn5yKlbfdj3UfdayNsCyLU6dO4dSpUwDsw6W8PA8PIYLAzff+udtVtADuOFfT
+GKph4IXgLMO1YsUKVS9kuA4B+DU7O7uku/3SAK7rnBsIIFoqlS7iOG42RVGhsbGx+oyMDEVKSgqt
+VqsRFBQEf8Z5cjIwuX7hzFlyBaRyBdZ/9j5amxt7NPo8z0EZFIarb3sAY6fM8nb3/Q5a5B3Pqr94
+kuFqaWlBUVHR+KKiorG5ubm3VVRUSB5++OEmkUh0qLW1dSuAarfjB/B1VFSUJSoqSjDVEomEVKvV
+UrVajYSEBJAkGeztAx5InD0rcR9LugRwJXP2YqSOnYzjv+1C/tnjqKsqh6GtFRzHQcQwkCtUUKiC
+ERoZjSTNaIzNnAmFKtjb3fZLaFHHQMhT1QZ/IigoyCHDRQJQcByHsrKyiKKiosuLiooWm0wmITq3
+pqZGVFNTw9AAMH36dGb58uUjpuxgZ88qYKz6hzIoBPOWXYWZiy6F1WKBzWYVJs7tVSdoiMRiMGJJ
+YMjdD2i64xbtLjHeHyFJUpDhWrRokUvg46ZNm7Bx48aRGWflPMFuN1Z9TzoO4IpzJHiAwYF2yrO1
+2UbegtDIksdox3lyMhBjFcBfcI70t3WRCjScGZHGymRy8qwCxiqAn+CskciybMBYjQScJyfpEaYQ
+EsB/ca4LNtzmrHrDCDVWHT807YP1tgIE8ISzsfK2arQ3GKHGqsOzEtEBzyqAf0BSrsPAkcaINFYW
+S8cEO32BGnsBAgw1pJNn5Vy3fqQwIo2VzdZhrJwnLQME8GUocmQbKxoAdu7caT506JCwRCaTyZCa
+mipPSUkZljJczpOTF6peHCDAUONcYbRz8T9/xyHHVVhYyObn5+udRYjb2trEAMQ0gCV6vb6zqKaq
+pKRk1u7duxdaLJYJcrnckpKSwqanpwclJycjMTGxz7LZvoSzsQp4VgH8BedhoD8bK5ZlUVpaCq1W
+i/z8fGNBQQGv1+tFEonknNls3tFeVkbX+XM0SZLb6U43LE3T4Djuu3YhTqq1tTXjxIkTU86fP+9R
+hquvJWG8TcBYBfBHSKpj1objeFdxCx+mvWRMj3JcJpPJLBKJwDCMW2iGzWazS3GlpKRg9OjRwhti
+sRjJycmIj48HRVHDSobLfuAdKykBYxXAX3AeBhIEfNJYdZbjys/P59va2ujeyHE5PqvVal3yd3Ny
+cpCTk2Ofs9JoNFi2bFmvO9SdDFdhYeH8bdu2zbNarbFRUVGt6enp0ri4OHF3CaxVVVVDdjJ5nneR
+KvcFjb4AAXqDsyKzow78UFBVVYU9e/Z0+T7P86isrLSeP3/eVF1dLROLxdU8z+/tqxwXRVFCMrMz
+Vqu1w1j1l65kuKqqqmbW1NTMomk6sbvPcxx3C8/zQ7IyyfOu7jPpx3NvAUYWRCdjxXGDb6x4nodW
+q2VLSkr+1107m81WynHcbwAOvPHGG4MixzVoboWTDFdvpLhuAjAky3Kdl3wDnlUAf8F+rfIACHAc
+NyTDwPbVc0t2dvbt3j7+ERdn1TkB1J9XNQOMLEiSdJH/8tfVwAtl0NwKZzkuAKE9NB8yi9G5dhUZ
+8KwC+AnOw0C7VzVkxorOysp6ooc2jRhEGS5gAI1VVlZWODrkuBY7y3HFxcV1G1V67tw5VFRUDMbx
+ucGynYzVhUh5BwjgBTqPAjpfy4MBSZKIi4sTjRkz5sXu2lVVVZk8yHDth12Gq34g+nJBxmqg5biM
+RuOQGavO43zn2JUAvYPn7UvnNEXa/0gSFEmAJO2KxM7rvjz49pggHjaOh43lYGM5sBw/xCKh/g9J
+0cLJ77xQNJgkJyfj6quv7qnZoMpwAb00VsNJjst5gp3n+cCcVS8gCEBM0xAzFMQiCmKaAk1RF2Rs
+CNgHLyzHw2JjYbbaYLKwMFls4EbYHExfoSm6fXrdsRroe5UXBkuGC7AbK7UHKa5wADOlUulChxxX
+XFycMT09XebvclxunlVgGOgREU1CLhZBJhZBLKIHzAtymCOKJCBlaEgZGmiXDzRbWRjMVrSZrLDY
+WAQcL1ecA5h5nnepy+ar9CTDlZeXd0d5eTnjJMP1M+xzX25DRxpAIcMwZrFYLISMikQiJCcn02lp
+abLk5GSHHJdvhqP3kc4rKAG1lQ5oioRSykAhZSDywvBYLLJ7biEKCSw2Fq0GC1qNloDH1Y5zDXYA
+LsHN/kQnGS6ZQ4ZLq9VenpeXt0ir1dqcdRLMZrPYYrGIaQBYtmyZePny5SOiGLlrzhEfWA0EIGVo
+BMnFkIl953nE0BTCVFKEKiXQGSxo1pvB+mB6yVDSuaqtP3hWvcFZhmvhwoWyzu+PaCkuZ0ayYyWX
+iBCikIChfXcoTBAEguRiqORi6AxmNLWZhiRy2xehKMplaDzS6rCPOGPlPAzk+ZHpWUnFNMKUMjC0
+/6yEEgCCZGIopQwaW43QGfxbkfhCICnK5enqr8PAC2XE3aluc1be7tAQQpEEIoJkPjXc6yskQSBc
+JYNCwqC22QDbCBoadk4NGy7DwN7iP4/WwYDHiBkHqmQMEiOC/NpQOSNhaMRHKIfN8fQGiqJcFoRG
+mmc14oyVc+gCj+GfG0iRBGJCFQhXyYadXSYJAtEhcoQoRoZkPUnRLsYqMGc1zBluN2x3SBkaUcFy
+kOTwPugQhQQ0RaKuxdD/nfkw9phAR1jtyJPjGnHGaqQQLBcjVCn1djeGDKWUAQGgdhgbLJIkQZAk
++PacwIBnFcDviQiSQSkdeao9CikDjudRrzN6uyuDAkEQoEgSjiybEelZnTt3zmYymQQzLRKJRElJ
+SVRycrLfptWMRAgCiA5R2FNYRigqmRhWlkOL3tz/nfkYBEm6pIcNN8+qpaUFWq0WJSUlrNUphL2o
+qIgGQNMAniwsLERhYaHwIZIkwxmGWWi1WsfLZDKbWq1m09PTVWq1GgkJCaADIgs+B0EQiA2VQywK
+/DZhSinMVnty9HCCIAiXKiH+7FnZbDaUlZWhqKgIBQUFxvz8fBgMBkoikeS0y3G5CUrQAF7q/CLH
+cSAIAizLUq2trRknT56ckpeXNyxkuIYjBAHEhiogFg3vlc2+EBUsR1m9bthFu/urZ9WVHFfn0jEk
+SVq6Oi4aAKKiohAVFSW8KJFIoFaroVar2YSEhLMkSTrLcKlqamqmO8lwTWUYhvQXGa7hBgEgJiRg
+qDrjCICtadL3f2c+gt2zcpWQ90UuRI6rPZkZRUVFKCoqgslkEvZXU1ODmpoau7GaPn06li9f3quO
+ZGdn6+AuwzWmXYZrwfbt2+daLJY4hwyXRqMRR0ZGdrvPtrY2b59fvyUyWA7JCJ6j6g65WASFRIQ2
+k7X/O/MRnOW4hsqzamtrQ0lJ9+WmamtrUVBQYM3LyzNXV1dLneS4dsIux3WuOzku52TmRYsWubw3
+YInM7fWWT7f//RcQZLhm1NTUzDp06NDFPM9HdLcPnuc1GFmZLwNCqFIKuSTgwXZHeJAMBrNu2JSZ
+cfashmrO6ty5c3xOTk5Bd20IgqgzmUzb2+W4Dg6GHNegPJLbZbi2tP8921P7rKwsM4ZIimu4oJAy
+CJaPiKo+/YIkCIQHSVHbPAzirwhiyOesOI6DyWQyZWdnp3n78Edcus1wgKEpRATJ+r+jEYJCwgyL
+oTIB73hWvsKg/oLtwhJjAUT20HQIjSbh8j9fnaTsrvdRwfLAmLmPhKukKK9v9XY3+o2zZzWE1y6Z
+lZV1cQ9tagGcHSwZLmCAjZWTHNdsiURyMUVREyQSCRseHm7qrnxwfX09bTAMjZvu0g8C4P3MWIWp
+pBD5UR0qX4GhKSilDFqN/lwHixhyY0WSJGQymTg8PPyrrtrwPI/6+nqJyWSiHn300VPtc1cDKsMF
+9MNY9VGOq9sxy9q1a7F3796BPs/DDglDQyULzFNdKKFKiZ8bK94rQaGZmZlYtWpVT0LFjliqaSUl
+JVOcZbhEItF+g8HgiKU6nJ2dfUHpBb02VllZWdEApvm7HJfz0i9A+M0wkAAQGZin6hcUSUIlY/y6
+yijppsrsOwymDBfQhbHKysqiAaQDmNPuNc0gSTI2KirKmJGRIR01ahSVmpqKsLAwb5+ffkEQ7nLy
+voqjDEqA/hEsl/itseLhaqx4Hw/H8CTDpdPpUFxcPL6kpGRsbm7u7cXFxeIHH3ywjWGYk3q9/icA
++wAcyc7ONnXeH00QRPNPP/0k+umnn5y/hFGpVKaUlBQqLS1NqlarER8fD5IkFd4+AQONj//eAOwS
+WUEjpMDcYENTpP8GivJw0Qzwx9VAlUqFCRMmOLwvOcdxKC8vDy4qKlqQl5c3vbCwkNXpdJIHHnjA
+5YlCEISV5nk+aMGCBVi8eLHwhlQqhVwuH3aGCUCnJGwCnB/84KFKaWD1bwAJkkv801jBdYHI1z2r
+3kCSJBITE5GYmIiFCxdKAUCv18NoNAo36s6dO7Fjxw77MFAmkyE8PNzb/fYSvv2DMzQFRSBKfUAR
+iygwNAWLzfcfVK7wnVYD/a3/vUMul0MulwvbMpl9rnbETYJ0rrnu6650qDIw/BsMlLJAwoS/MeKM
+lbMnRcC3XWmGpkaUestQopT4p7Fyrbrgu9fuoBy7tzsw5AdMOskZEYRPu9IjRbXFG5AkMSxScEYS
+I85YdY6k53306USRZKCiwiAj93Ov1ZdHBYPBiDNWrkGhvutKBwXmVAYdmVjk48sr7lB0xzDQX2IE
+B4qAseJ8szSsMpBWM+iIaBIicsTdAn7LiPul3IaBPvh0kolFoIa5MKmvEJi38h9oAKiqqsLRo0c7
+XqRpJCYmIiQkxNv9G3DcPCvW94zVSNT88xYShkKbqf/7CTAwNDc3o6SkxKWwYFVVFQCApijqu3Pn
+zknOnTvn/JkIs9k8QSwWsxqNhk9PT5cnJycjMTHR74UgSJIEQRDC5KSvDQMJAoFwhSEkIF3mPWw2
+G0pLS1FUVITz58/rCwsLCZPJRInF4jMAapzbUhRlolmWvaaLWlKUwWDIOHXq1JTz58/PIknyIrPZ
+rA4JCTGkp6eL09PTGX+U4eo8DPS1CXaZWAQiMAIcMphAbbAhwyHHlZ+fb83JyTFWVlbKSZJspWl6
+n9Fo3IZ2OS6DwXOmOQ0ADMNALO6Y0BWJREhOTmbT0tLOJicnn01ISPiUJElkZWUpGxoaJh44cGDe
+yZMnl5nN5ikikYhMSkpiHTJcKSkpYBjfHcYQBAGSJIXyGr5WfC8QrjC0kAQBmiJh88HpAE/wLv30
+3adaZzmuvLw8Tq/X02KxOM9JjmvXe++9V+eQ4dJqtcjLy4NWq4WTIDPMZjMsFovdWC1btqxXUlzZ
+2dmtAPa2//0LALKystS5ublzCwsLZ+3YsUPwvjIyMpi0tDRxYmIiYmJiQPiQu0BRlDAm9rWg0MAQ
+cGjhYc8U8Bdj5azSQ/rQSqbDa8rLy7Pm5uYaKysr5SKRqB7AbpPJtA92m3H89ddfdzvRzjJcCxcu
+dNv3QEpxFQEoQocIalBDQ8PM3377bfbx48cvslgsmTabTdrTfobSmJFOK22+VMBMLKJB+pBRHymI
+RRQMZv+rwjAUQaE8z2P37t3YvXt3t+1omjYyDHPcSY7rwHvvvdc8kH0Z8NnF7OzsFgBb2/96lOEC
+7FJcPM8PydjRbhSdymz4kLGSiQOTvd7An9SsnUsaUUNQjLHdIBqzs7O9XqbWd/zIIYSifLPMhjQQ
+8+MVJH60Isi7xNyPLC980H+ldmEJn6rLTjlVW/SVYSCBwDK6t6AoAiKahNXmG9dC17gWixzCOSsi
+Kyurp6BL3WDKcAGDYKyysrIiYK/ZPlsikSyhKGo8y7I95o4M5ZyV81f5imclElEgCV8vBTg84XlA
+yohgtV2Q6MrQQQAc2xEX6Fr1dpC+0h6TKAHQ2F07iqLMjz766EnnOauBlOEC+mmseiPHpdFoeqxC
+OtRSXM7DQF+Zs5KI6ICh8iJShoLOxxXmCWDIPSuCIDBv3jysWrWq23bNzc3i0tLS6SUlJVOdZbgo
+itpvMpkcMlyHsrOzL1ito0/GylmOSywWX0yS5BSJRML6kxyXI87Kga8MAxnafyZ5hyMSxh9CRgiw
+TiEWnaveepPBluECujFWnuS4aJqOjomJMWo0Grk/y3E5Dzl9payxWDQi1zp8Book/KAuOw/W1hFi
+4UvGqjM9yXDl5OTc4vC+eiPDBQA0TdPf/frrr8pff/1VeJFl2WiSJDNUKpVJo9FQqampznJc/vAI
+6vFEOvCFYSAPQBTwrLyOhKF93FgBNqc5K3/L0+0kw6Vqj1wPLioqWpCfnz+tsLCQ0+l0ksceeyyX
+oqhq58/SNN1K22y2lWlpacjMzBTeEIvFGDVqFBQKxbCU43I1Vt6fKaJIIhAM6gNIxTR0Bt+dZOd5
+V8/K34xVZ5wj1xctWiQDgNbWVpSUlIwzm83jHO2OHTuGI0eO2IeBMTExmDJlirf7PmQ4u8+sD1Rd
+EAWUln0CqR+EjrBOpVN8OQf3QlEqlRg3bpzLa44SMSPyLvG1YaDIh+ceRhJk+7yVr8LzPGzW4eNZ
+9ZURaawIwslY+UClUJoKDAF9BV/OIuA4DrZhNAzsK35lrByreM5VBC8E2unp6QuVQikfyp4f6fhy
+mWOOZV2Ggc5lnfqCo/yKL1VC6Q1+dZc4niQ1NTX93FMHvA+EYgbqrfsOYhEFX1W4slktLhkXEsmF
+6Uo67h9/88z8yliJxWIwDINjx471az8uuYE+EGc1FNnzAXqHiCJ99uFhsZhdysJIJD1WXvLIsWPH
+IBaLL9gz8xZ+d5cEBwdj27ZtaGtr83ZXBgQeCIQt+BA8AMZHS8ZYzCYXYyWV9t2z0ul02LZtG4KD
+g719OH3G74xVdHQ0zGYz3nvvvQveh7Mn4wueFemjT/KRCuOjnq7JoHfZlkr7XmLqvffeg9VqRVRU
+lLcPp8/QAGAwGFBf35EgzTAMVCrfTO8TiURISkrC119/jdGjR2PFihXe7lL/4EdaVSLfx1eH5QZ9
+qzApTpJkn+esfvrpJ3z77bdQq9U+PV+l0+lgsXTkOzsEbWiSJEv2798v379/v/Cm1WpVMAzDpaSk
+8Onp6XK1Wu1TMlzBwcGIiYnBv/71LyiVSo91m/0Jf1uVGe74rLFq6zBWDMNAIun9nNPOnTvx/PPP
+IyYmxqf0QK1WK0pLS6HVal3kuBiGaXVuR5KknuY4bpTRaHTbic1mU58+fXpuXl6eT8pwxcbGgqIo
+PP7448jKysIdd9zR65IZJOkcwe7dYSBBICC95WP4pqkC9K064f8ikQhicc+eFcdxWLNmDT744APE
+xcUhMjLSq8fgSViCJEkdSZJ7zWbzDthLyRw0Go1uRfFpgiDcsrc5joNKpSpKSUkpSktL+1StVuOF
+F17wORmuqKgoSCQSfPLJJ9iyZQsef/xxTJs2rcfPuXgyPrBMbTBZXfrkEk7RqX+du+u+zO4hGIPv
+sYVLW8e7hMfv4z19xOPnPffYvc98Tw06teV7OEC++8Pz0B/XV1kfyBf1hL61Rfi/Uqns0SM/ePAg
+XnnlFdTW1kKtViMoKGhI+9udHJfFYtlqs9l2A/jtySefrC8qKkJeXh4KCwuh0+ncHA+WZUHzPI8F
+CxZg8eLFwhtSqRRyudylsa/KcAUFBUGpVKK2thZ/+MMfkJqaimuvvRYXXXSR2zE4cD4RCjGBcMa7
+yiacsaX/O3Gip7MdcOQ60fmEUO1/PgZh7hgZKZUqjyOJtrY2bNu2DevWrUNRUREiIiKQnp4+JIX6
+OntNFRUVcoZheiXHlZiYKEzn6PV6OI/2du7ciR07dth/phUrVvRKN7AnsrKyggDMbC9pvNhisWSK
+RCJCpVJ1aw10Op3KbDYjJSWlXxP7LMuiqakJra2taG1tRVpaGiZNmoQJEyYgKioKKpUKQUFB+O23
+/Vi9+gNQFIU///lxpKWlD8JPFyDAwFJQUIBXXnkJFosFd9xxJyZMmAidTofq6mqcPn0ax48fR35+
+PlQqFRQKBUJCQvpV80qn06GwsBBisRgqlUrXQ1uR1WoFwzDHTCbTDqfSxs39PW6HbuCAGqvOZGVl
+EbCXPY7roelPAOjU1NQBW4W0Wq2ChWZZFjabDRaLRVB3ba8tPeDHHCDAYEMQRPuclT1IWiQSgSRJ
+YUQ0UAthOp0O+fn5AGAG0JOBqASQm52dPeD5awMmctod2dnZPICc9r8uycrKGvADFIlEQqnVAAEC
+9AsuOzt7u7c74asLHwECBAjggq8Yq8B4LEAA38Un7k9fMVYVQEfpigABAngfpyjyMm/3BfAdY3UW
+sC9ZBggQwDdwuh/PersvgO8Yqw8AoKGhod+F9QIECNB/rFYrGhsFEeYPvN0foD2RuaqqCkePHu14
+kaaRmJg4lDlEmwH8xnHcLK1Wi9TUVG+flwABRiw8z0Or1ToEgHcD2DpU393c3IySkhIXp8UhGEFQ
+FOWxCJfZbIZYLIZGo0F6ejqSk5MHLZl57dq12L17dxzseUFRoaGhSEpKGpKo2wABAnTAcRyKi4vR
+1NQE2GOnpsyfP7+6J/n4C8Fms6G0tBRFRUU4f/48CgsLYTKZurRHNMuyQgmGzhgMBpw6dQrnz58H
+SZIwm80ICQlBeno60tPTMZDJzCRJVnAcNw/ApsbGxjSTyYSEhAQMU+nCAAF8jtbWVpSVlfFGo5GA
+PTZyOUmS1f3drwNHOk5+fj5ycnJQWVkJkiRB07RLek1X9qhXQaFmc4fwY0NDAw4cOICTJ0/CbDYL
+9aU0Gg00Gg36k8ycmpqan5+fPxPAywaD4c7z58+TKpUKYWFhCAoK8mm57AAB/BGWZdHS0oL6+nq0
+trYC9jCFbABPpaamNhcWFl7wfp2SmJGXlwe9Xg+xWAyz2Qy2vegly7K9jgK4oAh2juOElQKbzYbc
+3FwUFhZix44dgveVkZGBtLQ09DWZecqUKU0Afn/06NF3ADym0+mu0+l0UgCQSCScVColaZoOGK4A
+AS4QR/qZ0WjkTCYTAXsqtwHA1wBemzJlyhnAnm7TW5ySmJGbm4vKykphyshkMgntuvKaesOgJeA7
+KhlaLJZerfARBAGNRuOWG3j06FElgGUAZgKYRhBEIoAwnueVg9X3AAGGMwRBtAJo4Hm+BMBhAAcA
+bJ0yZYqLsIFOp0NBQUGvcmhpmgbDMDCZTI6J+QHn/wEob20JztZfbwAAACV0RVh0ZGF0ZTpjcmVh
+dGUAMjAyMS0wNS0wNFQxMjoxNjo0NiswMDowMCdWA3UAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMjEt
+MDUtMDRUMTI6MTY6NDYrMDA6MDBWC7vJAAAAAElFTkSuQmCC" />
+</svg>
diff --git a/static/playground b/static/playground
new file mode 160000
index 00000000..8750ccf5
--- /dev/null
+++ b/static/playground
@@ -0,0 +1 @@
+Subproject commit 8750ccf5283f5f4c42ff4a0457a8537b9884602d
diff --git a/static/playground-home.js b/static/playground-home.js
new file mode 100644
index 00000000..c52a0dc1
--- /dev/null
+++ b/static/playground-home.js
@@ -0,0 +1,224 @@
+import { Simulator } from './playground/simulator.js';
+import { Editor } from './playground/resources/editor.bundle.min.js';
+
+// This file is for the playground on the home page.
+
+// Note: to test this locally, run the playground server!
+// Run the following in a terminal:
+//
+//    cd static/playground
+//    go run .
+//
+const PLAYGROUND_API = location.hostname == 'localhost' ? 'http://localhost:8080/api' : 'https://playground-bttoqog3vq-uc.a.run.app/api';
+
+// Initialize the playground embedded in the homepage.
+addEventListener('DOMContentLoaded', async () => {
+	let playground = document.querySelector('#playground');
+	let exampleSelect = playground.querySelector('.example_select');
+	let root = playground.querySelector('.simulator');
+	let firmwareButton = playground.querySelector('.playground-btn-flash');
+
+	// Load editor.
+	let editor = new Editor(playground.querySelector('.playground-editor'));
+
+	// Load simulator.
+	let state = structuredClone(examples[exampleSelect.value]);
+	editor.setText(state.code);
+	let simulator = new Simulator({
+		root: root,
+		editor: editor,
+		firmwareButton: firmwareButton,
+		baseURL: new URL('/playground/', document.baseURI),
+		apiURL: PLAYGROUND_API,
+		features: [],
+	});
+	await simulator.setState(state, state.target);
+
+	// Respond to changes in the example select box.
+	exampleSelect.disabled = false;
+	exampleSelect.addEventListener('change', async () => {
+		exampleSelect.disabled = true;
+		state = structuredClone(examples[exampleSelect.value]);
+		editor.setText(state.code);
+		await simulator.setState(state, state.target);
+		exampleSelect.disabled = false;
+	})
+});
+
+
+const exampleHello = `// You can edit this code!
+package main
+
+func main() {
+	println("hello world!")
+}`;
+
+const exampleBlink = `// You can edit this code!
+package main
+
+import (
+	"machine"
+	"time"
+)
+
+func main() {
+	led := machine.LED
+	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	for {
+		led.High()
+		time.Sleep(time.Second/2)
+
+		led.Low()
+		time.Sleep(time.Second/2)
+	}
+}`;
+
+const exampleST7789 = `package main
+
+import (
+	"machine"
+	"image/color"
+	"tinygo.org/x/drivers/st7789"
+)
+
+func main() {
+	// configure the display
+	machine.SPI0.Configure(machine.SPIConfig{
+		Frequency: 62_500_000, // 62.5MHz
+		Mode:      3,
+		SCK:       machine.SPI0_SCK_PIN,
+		SDI:       machine.SPI0_SDI_PIN,
+		SDO:       machine.SPI0_SDO_PIN,
+	})
+	display := st7789.New(machine.SPI0,
+		machine.TFT_RST,       // reset
+		machine.TFT_WRX,       // data/command
+		machine.TFT_CS,        // chip select
+		machine.TFT_BACKLIGHT) // backlight
+	display.Configure(st7789.Config{
+		Rotation: st7789.ROTATION_270,
+		Height:   320,
+	})
+
+	width, height := display.Size()
+
+	white := color.RGBA{255, 255, 255, 255}
+	red := color.RGBA{255, 0, 0, 255}
+	blue := color.RGBA{0, 0, 255, 255}
+	green := color.RGBA{0, 255, 0, 255}
+	black := color.RGBA{0, 0, 0, 255}
+
+	display.FillRectangle(0, 0, width/2, height/2, white)
+	display.FillRectangle(width/2, 0, width/2, height/2, red)
+	display.FillRectangle(0, height/2, width/2, height/2, green)
+	display.FillRectangle(width/2, height/2, width/2, height/2, blue)
+	display.FillRectangle(width/4, height/4, width/2, height/2, black)
+}`;
+
+const exampleLEDs = `package main
+
+import (
+	"image/color"
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/ws2812"
+)
+
+func main() {
+	// Set up the ring of RGB LEDs.
+	pin := machine.WS2812
+	pin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	ws := ws2812.New(pin)
+	leds := make([]color.RGBA, 10)
+
+	for cycle := uint8(0); ; cycle++ {
+		// Calculate a new color for each LED.
+		for i := range leds {
+			leds[i] = colorWheel(cycle*2 + uint8(i*8))
+		}
+
+		// Write colors to the LED ring.
+		ws.WriteColors(leds)
+
+		// Wait a bit each loop (running at around 30fps).
+		time.Sleep(time.Second / 30)
+	}
+}
+
+// Pick a color from the color wheel (red, then, green, then blue, and back to
+// red).
+func colorWheel(index uint8) color.RGBA {
+	index = 255-index
+	if index < 85 {
+		return color.RGBA{R: 255 - index*3, B: index * 3}
+	} else if index < 170 {
+		return color.RGBA{G: (index - 85) * 3, B: 255 - (index-85)*3}
+	} else {
+		return color.RGBA{R: (index - 170) * 3, G: 255 - (index-170)*3}
+	}
+}`;
+
+var examples = {
+	// Simple "hello world" example.
+	hello: {
+		target: 'console',
+		code: exampleHello,
+		parts: [
+			{
+				id: 'main',
+				location: 'parts/console.json',
+				x: 0,
+				y: 0,
+			}
+		],
+		wires: [],
+	},
+
+	// Simple "blinky light" example.
+	// The Arduino Uno, despite its limitations, is very well known and many
+	// people have one. So it seems like a good testcase.
+	arduino: {
+		target: 'arduino',
+		code: exampleBlink,
+		parts: [
+			{
+				id: 'main',
+				location: 'parts/arduino.json',
+				x: 0,
+				y: 0,
+			}
+		],
+		wires: [],
+	},
+
+	// Commonly used board, and a nice demo with LEDs.
+	circuitplay_express: {
+		target: 'circuitplay_express',
+		code: exampleLEDs,
+		parts: [
+			{
+				id: 'main',
+				location: 'parts/circuitplay-express.json',
+				x: 0,
+				y: 0,
+			},
+		],
+		wires: [],
+	},
+
+	// Our own Gopher Badge, which importantly has a display!
+	gopher_badge: {
+		target: 'gopher_badge',
+		code: exampleST7789,
+		parts: [
+			{
+				id: 'main',
+				location: 'parts/gopher-badge.json',
+				x: 0,
+				y: 0,
+			},
+		],
+		wires: [],
+	},
+};
diff --git a/static/playground-play.js b/static/playground-play.js
new file mode 100644
index 00000000..b762334b
--- /dev/null
+++ b/static/playground-play.js
@@ -0,0 +1,223 @@
+import { Simulator, upgradeOldState } from './playground/simulator.js';
+import { Editor } from './playground/resources/editor.bundle.min.js';
+import { boards } from './playground/boards.js';
+
+// This file is for the playground at the /play URL.
+
+const PLAYGROUND_API = location.hostname == 'localhost' ? 'http://localhost:8080/api' : 'https://playground-bttoqog3vq-uc.a.run.app/api';
+
+const defaultBoardName = 'console';
+
+let simulator = null;
+let editor = null;
+
+// Regexp for a URL like /s/abcdef
+let shareURLRegexp = RegExp('/s/([a-zA-Z0-9]*)$');
+
+// updateBoards updates the dropdown menu. This must be done on load or after
+// selecting a different board.
+function updateBoards(state) {
+  // Try to figure out the board name based on the saved state.
+  let activeName = '';
+  if (state) {
+    let matches = RegExp('parts/([a-z0-9-]+).json$').exec(state.parts[0].location);
+    if (matches) {
+      activeName = matches[1];
+      if (activeName === 'console' && state.compiler === 'go') {
+        activeName = 'console-go';
+      }
+    }
+    let button = document.querySelector('#target > button');
+    if (activeName in boards) {
+      button.textContent = boards[activeName].humanName;
+    } else {
+      // For some reason we couldn't find the board (should only happen with a
+      // malformed editor state).
+      button.textContent = '...';
+    }
+  }
+
+  // Replace the dropdown with a new dropdown.
+  let dropdown = document.querySelector('#target > .dropdown-menu');
+  dropdown.innerHTML = '';
+  for (let name in boards) {
+    let item = document.createElement('a');
+    item.textContent = boards[name].humanName;
+    item.classList.add('dropdown-item');
+    if (name === activeName) {
+      item.classList.add('active');
+    }
+    item.setAttribute('href', '');
+    item.dataset.name = name;
+    dropdown.appendChild(item);
+    item.addEventListener('click', (e) => {
+      e.preventDefault();
+      clearShareURL();
+      setBoard(item.dataset.name);
+    });
+  }
+}
+
+// setBoard reloads the editor and simulator to use the given board.
+async function setBoard(name) {
+  // Create a new clean state object for this board.
+  let board = boards[name];
+  let state = {
+    code: board.code,
+    compiler: board.compiler,
+    parts: [
+      {
+        id: 'main',
+        location: board.location,
+        x: 0,
+        y: 0,
+      },
+    ],
+    wires: [],
+  };
+
+  // Update the editor/simulator.
+  await setState(state);
+
+  // Load the same board after a reload.
+  localStorage.tinygo_playground_boardName = name;
+  delete localStorage.tinygo_playground_state;
+}
+
+// Reset the editor and simulator to use the given state.
+async function setState(state) {
+  upgradeOldState(state);
+  updateBoards(state);
+  editor.setText(state.code);
+
+  // Change to the new project state.
+  await simulator.setState(state);
+}
+
+// Load the editor state on page load.
+async function loadSavedState() {
+  // Check whether this is a share URL, and if so load the editor state from the
+  // API.
+  let matches = shareURLRegexp.exec(document.location.pathname);
+  if (matches) {
+    let id = matches[1];
+    let response = await fetch(`${PLAYGROUND_API}/share?id=${id}`);
+    if (response.status != 200) {
+      // Can't load the shared code.
+      // Users can still select a different sample from the dropdown. This is
+      // not very obvious, so might need a more explicit message.
+      simulator.terminal.appendError(`failed to fetch shared code: ${response.status} ${response.statusText}`);
+      return;
+    }
+    let state = await response.json();
+    setState(state.data);
+    return;
+  }
+
+  // Check whether the editor saved a previous state.
+  if (localStorage.tinygo_playground_state) {
+    setState(JSON.parse(localStorage.tinygo_playground_state));
+    return;
+  }
+
+  // Load the default board.
+  let board = localStorage.tinygo_playground_boardName;
+  if (!(board in boards)) {
+    board = defaultBoardName;
+  }
+  setBoard(board);
+}
+
+// Remove the /s/foobar suffix of the URL, and replace it with a bare /play/ URL
+// instead.
+function clearShareURL() {
+  let parts = shareURLRegexp.exec(document.location.pathname);
+  if (parts) {
+    let pathname = document.location.pathname;
+    pathname = pathname.substring(0, pathname.length-parts[0].length+1);
+    history.replaceState({}, '', pathname);
+  }
+}
+
+function setupShareButton() {
+  let modalElement = document.querySelector('#shareModal');
+  let input = modalElement.querySelector('input');
+  let button = modalElement.querySelector('button.copy-to-clipboard');
+
+  let copiedTooltip = new bootstrap.Tooltip(input, {
+    title: 'Copied to clipboard!',
+    trigger: 'manual',
+    placement: 'bottom',
+  });
+
+  let buttonTooltip = bootstrap.Tooltip.getOrCreateInstance(button);
+
+  document.querySelector('#btn-share').addEventListener('click', async e => {
+    e.preventDefault();
+
+    // Share modal with 'loading...' input.
+    input.value = '';
+    button.disabled = true;
+    let modal = new bootstrap.Modal(modalElement, {});
+    modal.show();
+
+    // Save the current code snippet.
+    let id = await simulator.share();
+
+    // Update the modal and URL.
+    let url;
+    if (shareURLRegexp.test(document.location.pathname)) {
+      url = new URL(id, document.location.href);
+    } else {
+      url = new URL('s/' + id, document.location.href);
+    }
+    history.replaceState({}, '', url);
+    input.value = url;
+    button.disabled = false;
+  });
+
+  button.addEventListener('click', e => {
+    e.preventDefault();
+    navigator.clipboard.writeText(input.value);
+    input.focus();
+
+    // Hide the 'Copy to clipboard' tooltip on the button.
+    buttonTooltip.hide();
+
+    // Show a new tooltip on the input element.
+    copiedTooltip.show();
+    setTimeout(() => {
+      copiedTooltip.hide();
+    }, 1500);
+  });
+
+  input.addEventListener('focus', e => {
+    input.select();
+  })
+}
+
+// Initialize the playground.
+document.addEventListener('DOMContentLoaded', async function(e) {
+  editor = new Editor(document.querySelector('.playground-editor'));
+
+  simulator = new Simulator({
+    root: document.querySelector('#output'),
+    editor: editor,
+    firmwareButton: document.querySelector('#btn-flash'),
+    baseURL: new URL('/playground/', document.baseURI),
+    apiURL: PLAYGROUND_API,
+    saveState: () => {
+      // Strip /s/* URL suffix.
+      clearShareURL();
+      localStorage.tinygo_playground_state = JSON.stringify(simulator.schematic.state);
+    },
+  });
+
+  setupShareButton();
+
+  // Update the drop down list of boards.
+  updateBoards();
+
+  // Now see which editor state we should load (depending on various things).
+  loadSavedState();
+})
diff --git a/static/tour-lis3dh.js b/static/tour-lis3dh.js
new file mode 100644
index 00000000..6f62a4c6
--- /dev/null
+++ b/static/tour-lis3dh.js
@@ -0,0 +1,128 @@
+import { setupTour } from '/tour.js';
+
+export function setupLIS3DH(code) {
+  let imuConfig = {
+  	humanName: 'Adafruit LIS3DH',
+  	svg: 'adafruit-lis3dh.svg',
+  };
+  setupTour({
+  	boards: {
+  		'arduino-nano33': {
+  			code: code.replace('SCL_PIN', 'A5').replace('SDA_PIN', 'A4'),
+  			parts: {
+  				main: {
+  					y: -10,
+  				},
+  				imu: {
+  					config: imuConfig,
+  					location: 'parts/adafruit-lis3dh.json',
+  					x: 5,
+  					y: 10,
+  					rotation: 180,
+  				}
+  			},
+  			wires: [
+  				{from: 'main.A5', to: 'imu.SCL'},
+  				{from: 'main.A4', to: 'imu.SDA'},
+  			],
+  		},
+  		'arduino': {
+  			code: code.replace('SCL_PIN', 'ADC5').replace('SDA_PIN', 'ADC4'),
+  			parts: {
+  				main: {
+  					y: 10,
+  				},
+  				imu: {
+  					config: imuConfig,
+  					location: 'parts/adafruit-lis3dh.json',
+  					x: -13,
+  					y: -30,
+  				},
+  			},
+  			wires: [
+  				{from: 'main.A5#2', to: 'imu.SCL'},
+  				{from: 'main.A4#2', to: 'imu.SDA'},
+  			],
+  		},
+  		'circuitplay-bluefruit': {
+    		code: code.replace('SCL_PIN', 'SCL1_PIN').replace('SDA_PIN', 'SDA1_PIN').replaceAll('Tx(0x18', 'Tx(0x19'),
+  		},
+  		'circuitplay-express': {
+  			code: code.replace('SCL_PIN', 'SCL1_PIN').replace('SDA_PIN', 'SDA1_PIN').replace('machine.I2C0', 'machine.I2C1').replaceAll('Tx(0x18', 'Tx(0x19'),
+  		},
+  		'microbit': {
+  			code: code.replace('SCL_PIN', 'P0').replace('SDA_PIN', 'P1'),
+  			parts: {
+  			  main: {
+  					x: 15,
+  				},
+  				imu: {
+  					config: imuConfig,
+  					location: 'parts/adafruit-lis3dh.json',
+  					y: -10,
+  					x: -30,
+  				},
+  			},
+  			wires: [
+  				{from: 'main.P0', to: 'imu.SCL'},
+  				{from: 'main.P1', to: 'imu.SDA'},
+  			],
+  		},
+  		'gopher-badge': {
+    		code: code.replace('SCL_PIN', 'I2C0_SCL_PIN').replace('SDA_PIN', 'I2C0_SDA_PIN'),
+  		},
+  		'reelboard': {
+  			code: code.replace('SCL_PIN', 'P0_27').replace('SDA_PIN', 'P0_26'),
+  			parts: {
+  				main: {
+  					x: -10,
+  				},
+  				imu: {
+  					config: imuConfig,
+  					location: 'parts/adafruit-lis3dh.json',
+  					x: 50,
+  				},
+  			},
+  			wires: [
+  				{from: 'main.P19', to: 'imu.SCL'},
+  				{from: 'main.P20', to: 'imu.SDA'},
+  			],
+  		},
+  		'pico': {
+  			code: code.replace('SCL_PIN', 'GP17').replace('SDA_PIN', 'GP16'),
+  			parts: {
+  				main: {
+  					y: 12,
+  				},
+  				imu: {
+  					config: imuConfig,
+  					location: 'parts/adafruit-lis3dh.json',
+  					x: 21,
+  					y: -13,
+  				},
+  			},
+  			wires: [
+  				{from: 'main.GP17', to: 'imu.SCL'},
+  				{from: 'main.GP16', to: 'imu.SDA'},
+  			],
+  		},
+  		'hifive1b': {
+  			code: code.replace('SCL_PIN', 'D19').replace('SDA_PIN', 'D18'),
+  			parts: {
+  				main: {
+  					x: -10,
+  				},
+  				imu: {
+  					config: imuConfig,
+  					location: 'parts/adafruit-lis3dh.json',
+  					x: 45,
+  					rotation: 180,
+  				},
+  			},
+  			wires: [
+  				{from: 'main.D19', to: 'imu.SCL'},
+  				{from: 'main.D18', to: 'imu.SDA'},
+  			],
+  		},
+  	}});
+}
diff --git a/static/tour.js b/static/tour.js
new file mode 100644
index 00000000..6491918d
--- /dev/null
+++ b/static/tour.js
@@ -0,0 +1,147 @@
+import { Simulator } from './playground/simulator.js';
+import { Editor } from '/playground/resources/editor.bundle.min.js';
+
+export { setupTour };
+
+// Note: to test this locally, run the playground server!
+// Run the following in a terminal:
+//
+//    cd static/playground
+//    go run .
+//
+const PLAYGROUND_API = location.hostname == 'localhost' ? 'http://localhost:8080/api' : 'https://playground-bttoqog3vq-uc.a.run.app/api';
+
+const boardNames = {
+	'arduino': 'Arduino Uno',
+	'arduino-nano33': 'Arduino Nano 33 IoT',
+	'circuitplay-bluefruit': 'Adafruit Circuit Playground Bluefruit',
+	'circuitplay-express': 'Adafruit Circuit Playground Express',
+	'gopher-badge': 'Gopher Badge',
+	'hifive1b': 'SiFive HiFive1 rev B',
+	'microbit': 'BBC micro:bit v1',
+	'pico': 'Raspberry Pi Pico',
+	'reelboard': 'Phytec reel board',
+}
+
+// Configure the tour. This works on pages that use the "tour" layout.
+// The config parameter has the following layout:
+//
+//   {
+//     code: '...',                // default code
+//     boards: {
+//       'arduino': {              // board name
+//          code: '...',           // code for this board (optional)
+//          parts: {               // extra parts besides the main part (optional)
+//            led: { ... },        // configuration for this part
+//          },
+//          wires: [               // wires (optional)
+//            {from: 'main.D2', to: 'led.anode'},
+//            {from: 'main.GND#2', to: 'led.cathode'},
+//          ],
+//       },
+//       'microbit': {},           // an empty value also works (and uses defaults)
+//     },
+//   }
+async function setupTour(config) {
+	let boards = [];
+	for (let boardName in config.boards) {
+		boards.push(boardName);
+	}
+	function createState(board) {
+		let state = {
+			target: board,
+			parts: [
+				{
+					id: 'main',
+					location: `parts/${board}.json`,
+					x: 0,
+					y: 0,
+				}
+			],
+			wires: [],
+		}
+		let boardConfig = config.boards[board];
+		if (boardConfig.code) {
+			state.code = boardConfig.code.trim();
+		} else {
+			state.code = config.code.trim();
+		}
+		for (let key in boardConfig.parts) {
+			let value = structuredClone(boardConfig.parts[key]);
+			value.id = key;
+			value.x = value.x || 0;
+			value.y = value.y || 0;
+			if (key === 'main') {
+				Object.assign(state.parts[0], value);
+			} else {
+				state.parts.push(value);
+			}
+		}
+		for (let wire of (boardConfig.wires) || []) {
+			state.wires.push(wire);
+		}
+
+		return state;
+	}
+
+	let root = document.querySelector('.simulator');
+	let editor = new Editor(document.querySelector('.playground-editor'));
+	let firmwareButton = document.querySelector('.playground-btn-flash');
+	let resetButton = document.querySelector('.playground-btn-reset');
+
+	// Pick default board.
+	let currentBoard = boards[0];
+	if (localStorage.tinygo_tour_board in config.boards) {
+		// The user previously picked a different board.
+		currentBoard = localStorage.tinygo_tour_board;
+	}
+
+	let boardButton = document.querySelector('#board .dropdown-toggle');
+	let boardMenu = document.querySelector('#board .dropdown-menu');
+	for (let board of boards) {
+		let boardName = boardNames[board] || board;
+		let a = document.createElement('a');
+		a.textContent = boardName;
+		a.classList.add('dropdown-item');
+		if (board === currentBoard) {
+			a.classList.add('active');
+			boardButton.textContent = boardName;
+		}
+		a.href = "";
+		a.addEventListener('click', async e => {
+			// Select a different board.
+			localStorage.tinygo_tour_board = board;
+			e.preventDefault();
+			boardMenu.querySelector('a.dropdown-item.active').classList.remove('active');
+			a.classList.add('active');
+			boardButton.textContent = boardName;
+			currentBoard = board;
+			state = createState(currentBoard);
+			editor.setText(state.code);
+			await simulator.setState(state, currentBoard);
+		})
+		boardMenu.appendChild(a);
+	}
+
+	// Load simulator.
+	let state = createState(currentBoard);
+	editor.setText(state.code);
+	let simulator = new Simulator({
+		root: root,
+		editor: editor,
+		features: [],
+		firmwareButton: firmwareButton,
+		baseURL: new URL('/playground/', document.baseURI),
+		apiURL: PLAYGROUND_API,
+	});
+	await simulator.setState(state, state.target);
+
+	resetButton.disabled = false;
+	resetButton.addEventListener('click', async e => {
+		resetButton.disabled = true;
+		state = createState(currentBoard);
+		editor.setText(state.code);
+		await simulator.setState(state, currentBoard);
+		resetButton.disabled = false;
+	});
+}
diff --git a/static/x/device/index.html b/static/x/device/index.html
new file mode 100644
index 00000000..ab90441b
--- /dev/null
+++ b/static/x/device/index.html
@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+<meta name="go-import" content="tinygo.org/x/device git https://github.com/tinygo-org/device">
+<meta name="go-source" content="tinygo.org/x/device _ https://github.com/tinygo-org/device/tree/main{/dir} https://github.com/tinygo-org/device/blob/main{/dir}/{file}#L{line}">
+<meta http-equiv="refresh" content="0; url=https://tinygo.org/">
+</head>
+<body>
+Nothing to see here; <a href="https://tinygo.org/">move along</a>.
+</body>
\ No newline at end of file
diff --git a/static/x/tinyfs/index.html b/static/x/tinyfs/index.html
new file mode 100644
index 00000000..6f9107c5
--- /dev/null
+++ b/static/x/tinyfs/index.html
@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+<meta name="go-import" content="tinygo.org/x/tinyfs git https://github.com/tinygo-org/tinyfs">
+<meta name="go-source" content="tinygo.org/x/tinyfs _ https://github.com/tinygo-org/tinyfs/tree/release{/dir} https://github.com/tinygo-org/tinyfs/blob/release{/dir}/{file}#L{line}">
+<meta http-equiv="refresh" content="0; url=https://tinygo.org/">
+</head>
+<body>
+Nothing to see here; <a href="https://tinygo.org/">move along</a>.
+</body>
\ No newline at end of file
diff --git a/static/x/tinygba/index.html b/static/x/tinygba/index.html
new file mode 100644
index 00000000..46e452f2
--- /dev/null
+++ b/static/x/tinygba/index.html
@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+<meta name="go-import" content="tinygo.org/x/tinygba git https://github.com/tinygo-org/tinygba">
+<meta name="go-source" content="tinygo.org/x/tinygba _ https://github.com/tinygo-org/tinygba/tree/main{/dir} https://github.com/tinygo-org/tinygba/blob/main{/dir}/{file}#L{line}">
+<meta http-equiv="refresh" content="0; url=https://tinygo.org/">
+</head>
+<body>
+Nothing to see here; <a href="https://tinygo.org/">move along</a>.
+</body>
diff --git a/static/x/tinygl-font/index.html b/static/x/tinygl-font/index.html
new file mode 100644
index 00000000..2d7a9c75
--- /dev/null
+++ b/static/x/tinygl-font/index.html
@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+<meta name="go-import" content="tinygo.org/x/tinygl-font git https://github.com/tinygo-org/tinygl-font">
+<meta name="go-source" content="tinygo.org/x/tinygl-font _ https://github.com/tinygo-org/tinygl-font/tree/release{/dir} https://github.com/tinygo-org/tinygl-font/blob/release{/dir}/{file}#L{line}">
+<meta http-equiv="refresh" content="0; url=https://tinygo.org/">
+</head>
+<body>
+Nothing to see here; <a href="https://tinygo.org/">move along</a>.
+</body>
\ No newline at end of file
diff --git a/static/x/tinygl/index.html b/static/x/tinygl/index.html
new file mode 100644
index 00000000..49423919
--- /dev/null
+++ b/static/x/tinygl/index.html
@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+<meta name="go-import" content="tinygo.org/x/tinygl git https://github.com/tinygo-org/tinygl">
+<meta name="go-source" content="tinygo.org/x/tinygl _ https://github.com/tinygo-org/tinygl/tree/release{/dir} https://github.com/tinygo-org/tinygl/blob/release{/dir}/{file}#L{line}">
+<meta http-equiv="refresh" content="0; url=https://tinygo.org/">
+</head>
+<body>
+Nothing to see here; <a href="https://tinygo.org/">move along</a>.
+</body>
diff --git a/themes/learn b/themes/learn
deleted file mode 160000
index 1d2d7f97..00000000
--- a/themes/learn
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 1d2d7f97a634c281f8a85e1efaed190d0d814f07