wirish reformatted and code-styled

23 files changed, 685 insertions, 567 deletions

diff --git a/wirish/HardwareTimer.cpp b/wirish/HardwareTimer.cpp
index 99863c1..6fbad8b 100644
--- a/wirish/HardwareTimer.cpp
+++ b/wirish/HardwareTimer.cpp
@@ -1,4 +1,4 @@
-/* *****************************************************************************
+/******************************************************************************
  * The MIT License
  *
  * Copyright (c) 2010 Bryan Newbold.
@@ -20,7 +20,7 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
- * ****************************************************************************/
+ *****************************************************************************/
 
 /**
  *  @brief wirish timer class to manage the four 16-bit timer peripherals
@@ -43,99 +43,127 @@ HardwareTimer::HardwareTimer(uint8 timerNum) {
 void HardwareTimer::resume(void) {
     timer_resume(this->timerNum);
 }
+
 void HardwareTimer::pause(void) {
     timer_pause(this->timerNum);
 }
+
 void HardwareTimer::setPrescaleFactor(uint16 factor) {
     // The prescaler register is zero-indexed
     timer_set_prescaler(this->timerNum, factor-1);
 }
+
 void HardwareTimer::setOverflow(uint16 val) {
     this->overflow = val;
     timer_set_reload(this->timerNum, val);
 }
-void HardwareTimer::setCount(uint16 val) {    
-    if(val > this->overflow)
+
+void HardwareTimer::setCount(uint16 val) {
+    if(val > this->overflow) {
         val = this->overflow;
+    }
     timer_set_count(this->timerNum, val);
 }
+
 uint16 HardwareTimer::getCount(void) {
     return timer_get_count(this->timerNum);
 }
 
-// This function will set the prescaler and overflow to get
-// a period of the given length with the most resolution; 
-// the return value is the overflow value and thus the largest
-// value that can be set as a compare.
+/* This function will set the prescaler and overflow to get a period
+ * of the given length with the most resolution; the return value is
+ * the overflow value and thus the largest value that can be set as a
+ * compare. */
 uint16 HardwareTimer::setPeriod(uint32 microseconds) {
     // XXX: 72MHz shouldn't be hard coded in here... global define?
-    
+
     // Not the best way to handle this edge case?
     if(!microseconds) {
         setPrescaleFactor(1);
         setOverflow(1);
         return this->overflow;
     }
+
     // With a prescale factor of 1, there are 72counts/ms
     uint16 ps = ((microseconds*72)/65536) + 1;
     setPrescaleFactor(ps);
+
     // Finally, this overflow will always be less than 65536
     setOverflow(((microseconds*72)/ps) - 1);
-    return this->overflow;    
+    return this->overflow;
 }
+
 void HardwareTimer::setChannel1Mode(uint8 mode) {
     timer_set_mode(this->timerNum,1,mode);
 }
+
 void HardwareTimer::setChannel2Mode(uint8 mode) {
     timer_set_mode(this->timerNum,2,mode);
 }
+
 void HardwareTimer::setChannel3Mode(uint8 mode) {
     timer_set_mode(this->timerNum,3,mode);
 }
+
 void HardwareTimer::setChannel4Mode(uint8 mode) {
     timer_set_mode(this->timerNum,4,mode);
 }
+
 void HardwareTimer::setCompare1(uint16 val) {
-    if(val > this->overflow)
+    if(val > this->overflow) {
         val = this->overflow;
+    }
     timer_set_compare_value(this->timerNum,1,val);
 }
+
 void HardwareTimer::setCompare2(uint16 val) {
-    if(val > this->overflow)
+    if(val > this->overflow) {
         val = this->overflow;
+    }
     timer_set_compare_value(this->timerNum,2,val);
 }
+
 void HardwareTimer::setCompare3(uint16 val) {
-    if(val > this->overflow)
+    if(val > this->overflow) {
         val = this->overflow;
+    }
     timer_set_compare_value(this->timerNum,3,val);
 }
+
 void HardwareTimer::setCompare4(uint16 val) {
-    if(val > this->overflow)
+    if(val > this->overflow) {
         val = this->overflow;
+    }
     timer_set_compare_value(this->timerNum,4,val);
 }
+
 void HardwareTimer::attachCompare1Interrupt(voidFuncPtr handler) {
     timer_attach_interrupt(this->timerNum,1,handler);
 }
+
 void HardwareTimer::attachCompare2Interrupt(voidFuncPtr handler) {
     timer_attach_interrupt(this->timerNum,2,handler);
 }
+
 void HardwareTimer::attachCompare3Interrupt(voidFuncPtr handler) {
     timer_attach_interrupt(this->timerNum,3,handler);
 }
+
 void HardwareTimer::attachCompare4Interrupt(voidFuncPtr handler) {
     timer_attach_interrupt(this->timerNum,4,handler);
 }
+
 void HardwareTimer::detachCompare1Interrupt(void) {
     timer_detach_interrupt(this->timerNum,1);
 }
+
 void HardwareTimer::detachCompare2Interrupt(void) {
     timer_detach_interrupt(this->timerNum,2);
 }
+
 void HardwareTimer::detachCompare3Interrupt(void) {
     timer_detach_interrupt(this->timerNum,3);
 }
+
 void HardwareTimer::detachCompare4Interrupt(void) {
     timer_detach_interrupt(this->timerNum,4);
 }
diff --git a/wirish/HardwareTimer.h b/wirish/HardwareTimer.h
index aa48718..c6e11c8 100644
--- a/wirish/HardwareTimer.h
+++ b/wirish/HardwareTimer.h
@@ -1,4 +1,4 @@
-/* *****************************************************************************
+/******************************************************************************
  * The MIT License
  *
  * Copyright (c) 2010 Bryan Newbold.
@@ -20,7 +20,7 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
- * ****************************************************************************/
+ *****************************************************************************/
 
 /**
  *  @brief wirish timer class to manage the four 16-bit timer peripherals
@@ -30,38 +30,38 @@
 #define _TIMER_H_
 
 class HardwareTimer {
-    private:
-        uint16 overflow;
-        uint8 timerNum;
+ private:
+    uint16 overflow;
+    uint8 timerNum;
 
-    public:
-        HardwareTimer(uint8 timer_num);
+ public:
+    HardwareTimer(uint8 timer_num);
 
-        void pause(void);
-        void resume(void);
-        void setPrescaleFactor(uint16 factor);
-        void setOverflow(uint16 val); // truncates to overflow
-        void setCount(uint16 val);    // truncates to overflow
-        uint16 getCount(void);
+    void pause(void);
+    void resume(void);
+    void setPrescaleFactor(uint16 factor);
+    void setOverflow(uint16 val); // truncates to overflow
+    void setCount(uint16 val);    // truncates to overflow
+    uint16 getCount(void);
 
-        // tries to set prescaler and overflow wisely; returns overflow
-        uint16 setPeriod(uint32 microseconds); 
-        void setChannel1Mode(uint8 mode);
-        void setChannel2Mode(uint8 mode);
-        void setChannel3Mode(uint8 mode);
-        void setChannel4Mode(uint8 mode);
-        void setCompare1(uint16 val); // truncates to overflow
-        void setCompare2(uint16 val); // truncates to overflow
-        void setCompare3(uint16 val); // truncates to overflow
-        void setCompare4(uint16 val); // truncates to overflow
-        void attachCompare1Interrupt(voidFuncPtr handler);
-        void attachCompare2Interrupt(voidFuncPtr handler);
-        void attachCompare3Interrupt(voidFuncPtr handler);
-        void attachCompare4Interrupt(voidFuncPtr handler);
-        void detachCompare1Interrupt(void);
-        void detachCompare2Interrupt(void);
-        void detachCompare3Interrupt(void);
-        void detachCompare4Interrupt(void);
+    // tries to set prescaler and overflow wisely; returns overflow
+    uint16 setPeriod(uint32 microseconds);
+    void setChannel1Mode(uint8 mode);
+    void setChannel2Mode(uint8 mode);
+    void setChannel3Mode(uint8 mode);
+    void setChannel4Mode(uint8 mode);
+    void setCompare1(uint16 val); // truncates to overflow
+    void setCompare2(uint16 val); // truncates to overflow
+    void setCompare3(uint16 val); // truncates to overflow
+    void setCompare4(uint16 val); // truncates to overflow
+    void attachCompare1Interrupt(voidFuncPtr handler);
+    void attachCompare2Interrupt(voidFuncPtr handler);
+    void attachCompare3Interrupt(voidFuncPtr handler);
+    void attachCompare4Interrupt(voidFuncPtr handler);
+    void detachCompare1Interrupt(void);
+    void detachCompare2Interrupt(void);
+    void detachCompare3Interrupt(void);
+    void detachCompare4Interrupt(void);
 };
 
 extern HardwareTimer Timer1;
diff --git a/wirish/Print.cpp b/wirish/Print.cpp
index 9baa757..c66ca61 100644
--- a/wirish/Print.cpp
+++ b/wirish/Print.cpp
@@ -1,213 +1,190 @@
 /*
- Print.cpp - Base class that provides print() and println()
- Copyright (c) 2008 David A. Mellis.  All right reserved.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
- Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-
- Modified 23 November 2006 by David A. Mellis
+ * Print.cpp - Base class that provides print() and println()
+ * Copyright (c) 2008 David A. Mellis.  All right reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ * Modified 23 November 2006 by David A. Mellis
  */
 
 #include "wirish.h"
 #include "Print.h"
 
-// Public Methods //////////////////////////////////////////////////////////////
-
-/* default implementation: may be overridden */
-void Print::write(const char *str)
-{
-  while (*str)
-    write(*str++);
-}
-
-/* default implementation: may be overridden */
-void Print::write(void *buffer, uint32 size)
-{
-   uint8 *ch = (uint8*)buffer;
-   while (size--) {
-      write(*ch++);
-   }
-}
+//------------------------------ Public Methods -------------------------------
 
-void Print::print(uint8 b)
-{
-  this->write(b);
+void Print::write(const char *str) {
+    while (*str)
+        write(*str++);
 }
 
-void Print::print(char c)
-{
-  print((byte) c);
+void Print::write(void *buffer, uint32 size) {
+    uint8 *ch = (uint8*)buffer;
+    while (size--) {
+        write(*ch++);
+    }
 }
 
-void Print::print(const char str[])
-{
-  write(str);
+void Print::print(uint8 b) {
+    this->write(b);
 }
 
-void Print::print(int n)
-{
-  print((long) n);
+void Print::print(char c) {
+    print((byte) c);
 }
 
-void Print::print(unsigned int n)
-{
-  print((unsigned long) n);
+void Print::print(const char str[]) {
+    write(str);
 }
 
-void Print::print(long n)
-{
-  if (n < 0) {
-    print('-');
-    n = -n;
-  }
-  printNumber(n, 10);
+void Print::print(int n) {
+    print((long) n);
 }
 
-void Print::print(unsigned long n)
-{
-  printNumber(n, 10);
+void Print::print(unsigned int n) {
+    print((unsigned long) n);
 }
 
-void Print::print(long n, int base)
-{
-  if (base == 0)
-    print((char) n);
-  else if (base == 10)
-    print(n);
-  else
-    printNumber(n, base);
+void Print::print(long n) {
+    if (n < 0) {
+        print('-');
+        n = -n;
+    }
+    printNumber(n, 10);
 }
 
-void Print::print(double n)
-{
-  printFloat(n, 2);
+void Print::print(unsigned long n) {
+    printNumber(n, 10);
 }
 
-void Print::println(void)
-{
-  print('\r');
-  print('\n');
+void Print::print(long n, int base) {
+    if (base == 0) {
+        print((char) n);
+    } else if (base == 10) {
+        print(n);
+    } else {
+        printNumber(n, base);
+    }
 }
 
-void Print::println(char c)
-{
-  print(c);
-  println();
+void Print::print(double n) {
+    printFloat(n, 2);
 }
 
-void Print::println(const char c[])
-{
-  print(c);
-  println();
+void Print::println(void) {
+    print('\r');
+    print('\n');
 }
 
-void Print::println(uint8 b)
-{
-  print(b);
-  println();
+void Print::println(char c) {
+    print(c);
+    println();
 }
 
-void Print::println(int n)
-{
-  print(n);
-  println();
+void Print::println(const char c[]) {
+    print(c);
+    println();
 }
 
-void Print::println(unsigned int n)
-{
-  print(n);
-  println();
+void Print::println(uint8 b) {
+    print(b);
+    println();
 }
 
-void Print::println(long n)
-{
-  print(n);
-  println();
+void Print::println(int n) {
+    print(n);
+    println();
 }
 
-void Print::println(unsigned long n)
-{
-  print(n);
-  println();
+void Print::println(unsigned int n) {
+    print(n);
+    println();
 }
 
-void Print::println(long n, int base)
-{
-  print(n, base);
-  println();
+void Print::println(long n) {
+    print(n);
+    println();
 }
 
-void Print::println(double n)
-{
-  print(n);
-  println();
+void Print::println(unsigned long n) {
+    print(n);
+    println();
 }
 
-// Private Methods /////////////////////////////////////////////////////////////
-
-void Print::printNumber(unsigned long n, uint8 base)
-{
-  unsigned char buf[8 * sizeof(long)]; // Assumes 8-bit chars.
-  unsigned long i = 0;
-
-  if (n == 0) {
-    print('0');
-    return;
-  }
-
-  while (n > 0) {
-    buf[i++] = n % base;
-    n /= base;
-  }
-
-  for (; i > 0; i--)
-    print((char) (buf[i - 1] < 10 ?
-      '0' + buf[i - 1] :
-      'A' + buf[i - 1] - 10));
+void Print::println(long n, int base) {
+    print(n, base);
+    println();
 }
 
-void Print::printFloat(double number, uint8 digits)
-{
-  // Handle negative numbers
-  if (number < 0.0)
-  {
-     print('-');
-     number = -number;
-  }
-
-  // Round correctly so that print(1.999, 2) prints as "2.00"
-  double rounding = 0.5;
-  for (uint8 i=0; i<digits; ++i)
-    rounding /= 10.0;
-
-  number += rounding;
-
-  // Extract the integer part of the number and print it
-  unsigned long int_part = (unsigned long)number;
-  double remainder = number - (double)int_part;
-  print(int_part);
-
-  // Print the decimal point, but only if there are digits beyond
-  if (digits > 0)
-    print(".");
-
-  // Extract digits from the remainder one at a time
-  while (digits-- > 0)
-  {
-    remainder *= 10.0;
-    int toPrint = int(remainder);
-    print(toPrint);
-    remainder -= toPrint;
-  }
+void Print::println(double n) {
+    print(n);
+    println();
+}
+
+//------------------------------ Private Methods ------------------------------
+
+void Print::printNumber(unsigned long n, uint8 base) {
+    unsigned char buf[8 * sizeof(long)]; // Assumes 8-bit chars.
+    unsigned long i = 0;
+
+    if (n == 0) {
+        print('0');
+        return;
+    }
+
+    while (n > 0) {
+        buf[i++] = n % base;
+        n /= base;
+    }
+
+    for (; i > 0; i--)
+        print((char) (buf[i - 1] < 10 ?
+                      '0' + buf[i - 1] :
+                      'A' + buf[i - 1] - 10));
+}
+
+void Print::printFloat(double number, uint8 digits) {
+    // Handle negative numbers
+    if (number < 0.0) {
+        print('-');
+        number = -number;
+    }
+
+    // Round correctly so that print(1.999, 2) prints as "2.00"
+    double rounding = 0.5;
+    for (uint8 i=0; i<digits; ++i) {
+        rounding /= 10.0;
+    }
+
+    number += rounding;
+
+    // Extract the integer part of the number and print it
+    unsigned long int_part = (unsigned long)number;
+    double remainder = number - (double)int_part;
+    print(int_part);
+
+    // Print the decimal point, but only if there are digits beyond
+    if (digits > 0) {
+        print(".");
+    }
+
+    // Extract digits from the remainder one at a time
+    while (digits-- > 0) {
+        remainder *= 10.0;
+        int toPrint = int(remainder);
+        print(toPrint);
+        remainder -= toPrint;
+    }
 }
diff --git a/wirish/Print.h b/wirish/Print.h
index 9c03978..dc21183 100644
--- a/wirish/Print.h
+++ b/wirish/Print.h
@@ -1,21 +1,22 @@
 /*
-  Print.h - Base class that provides print() and println()
-  Copyright (c) 2008 David A. Mellis.  All right reserved.
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of the GNU Lesser General Public
-  License along with this library; if not, write to the Free Software
-  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-*/
+ * Print.h - Base class that provides print() and println()
+ * Copyright (c) 2008 David A. Mellis.  All right reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA.
+ */
 
 #ifndef Print_h
 #define Print_h
@@ -31,10 +32,10 @@
 
 class Print
 {
-  private:
+ private:
     void printNumber(unsigned long, uint8);
     void printFloat(double, uint8);
-  public:
+ public:
     virtual void write(uint8) = 0;
     virtual void write(const char *str);
     virtual void write(void *, uint32);
diff --git a/wirish/WProgram.h b/wirish/WProgram.h
index 9143991..36984ff 100644
--- a/wirish/WProgram.h
+++ b/wirish/WProgram.h
@@ -1,4 +1,4 @@
-/* *****************************************************************************
+/******************************************************************************
  * The MIT License
  *
  * Copyright (c) 2010 LeafLabs LLC.
@@ -20,7 +20,7 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
- * ****************************************************************************/
+ *****************************************************************************/
 
 #include "wirish.h"
 
diff --git a/wirish/bits.h b/wirish/bits.h
index 7ebea80..7b51e5e 100644
--- a/wirish/bits.h
+++ b/wirish/bits.h
@@ -1,23 +1,23 @@
 /*

-  Part of Arduino - http://www.arduino.cc/

-

-  Copyright (c) 2005-2006 David A. Mellis

-

-  This library is free software; you can redistribute it and/or

-  modify it under the terms of the GNU Lesser General Public

-  License as published by the Free Software Foundation; either

-  version 2.1 of the License, or (at your option) any later version.

-

-  This library is distributed in the hope that it will be useful,

-  but WITHOUT ANY WARRANTY; without even the implied warranty of

-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

-  Lesser General Public License for more details.

-

-  You should have received a copy of the GNU Lesser General

-  Public License along with this library; if not, write to the

-  Free Software Foundation, Inc., 59 Temple Place, Suite 330,

-  Boston, MA  02111-1307  USA

-*/

+ * Part of Arduino - http://www.arduino.cc/

+ *

+ * Copyright (c) 2005-2006 David A. Mellis

+ *

+ * This library is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public License

+ * as published by the Free Software Foundation; either version 2.1 of

+ * the License, or (at your option) any later version.

+ *

+ * This library is distributed in the hope that it will be useful, but

+ * WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with this library; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307

+ * USA

+ */

 

 // BIT DEFINITION

 

diff --git a/wirish/boards.h b/wirish/boards.h
index 0e0d159..eed3e26 100644
--- a/wirish/boards.h
+++ b/wirish/boards.h
@@ -1,4 +1,4 @@
-/* *****************************************************************************
+/******************************************************************************
  * The MIT License
  *
  * Copyright (c) 2010 Bryan Newbold.
@@ -20,12 +20,13 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
- * ****************************************************************************/
+ *****************************************************************************/
 
-// This file contains BOARD-specific pin mapping tables. To add a new board
-// type, copy the "BOARD_maple" section below and edit it as needed, then
-// update your build toolchain with a new "BOARD" type. This must match the
-// seperate MCU type (which determines the ../libmaple configuration).
+/* This file contains board-specific pin mapping tables. To add a new board
+ * type, copy the "BOARD_maple" section below and edit it as needed, then
+ * update your build toolchain with a new "BOARD" type. This must match the
+ * separate MCU type (which determines the ../libmaple configuration).
+ */
 
 #ifndef _BOARDS_H_
 #define _BOARDS_H_
@@ -36,10 +37,10 @@
 #include "exti.h"
 
 #ifdef __cplusplus
-extern "C"{
+extern "C" {
 #endif
 
-// Set of all possible digital pin names; not all boards have all these
+/* Set of all possible digital pin names; not all boards have all these */
 enum {
     D0, D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, D15, D16,
     D17, D18, D19, D20, D21, D22, D23, D24, D25, D26, D27, D28, D29, D30, D31,
@@ -50,7 +51,7 @@ enum {
     D92, D93, D94, D95, D96, D97, D98, D99, D100, D101, D102, D103, D104, D105,
     D106, D107, D108, D109, D110, D111, };
 
-// Set of all possible analog pin names; not all boards have all these
+/* Set of all possible analog pin names; not all boards have all these */
 enum {
     ADC0, ADC1, ADC2, ADC3, ADC4, ADC5, ADC6, ADC7, ADC8, ADC9, ADC10, ADC11,
     ADC12, ADC13, ADC14, ADC15, ADC16, ADC17, ADC18, ADC19, ADC20, };
@@ -58,7 +59,7 @@ enum {
 #define ADC_INVALID       0xFFFFFFFF
 #define TIMER_INVALID     (TimerCCR)0xFFFFFFFF
 
-// Types used for the tables below
+/* Types used for the tables below */
 typedef struct PinMapping {
     GPIO_Port *port;
     uint32 pin;
@@ -67,59 +68,102 @@ typedef struct PinMapping {
     uint32 exti_port;
 } PinMapping;
 
-// LeafLabs Maple rev3, rev4
+/* LeafLabs Maple rev3, rev4 */
 #ifdef BOARD_maple
 
     #define CYCLES_PER_MICROSECOND  72
     #define MAPLE_RELOAD_VAL        71999 /* takes a cycle to reload */
 
     static __attribute__ ((unused)) PinMapping PIN_MAP[NR_GPIO_PINS] = {
-        {GPIOA_BASE,  3,        ADC3, TIMER2_CH4_CCR,  EXTI_CONFIG_PORTA}, // D0/PA3
-        {GPIOA_BASE,  2,        ADC2, TIMER2_CH3_CCR,  EXTI_CONFIG_PORTA}, // D1/PA2
-        {GPIOA_BASE,  0,        ADC0, TIMER2_CH1_CCR,  EXTI_CONFIG_PORTA}, // D2/PA0
-        {GPIOA_BASE,  1,        ADC1, TIMER2_CH2_CCR,  EXTI_CONFIG_PORTA}, // D3/PA1
-        {GPIOB_BASE,  5, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTB}, // D4/PB5
-        {GPIOB_BASE,  6, ADC_INVALID, TIMER4_CH1_CCR,  EXTI_CONFIG_PORTB}, // D5/PB6
-        {GPIOA_BASE,  8, ADC_INVALID, TIMER1_CH1_CCR,  EXTI_CONFIG_PORTA}, // D6/PA8
-        {GPIOA_BASE,  9, ADC_INVALID, TIMER1_CH2_CCR,  EXTI_CONFIG_PORTA}, // D7/PA9
-        {GPIOA_BASE, 10, ADC_INVALID, TIMER1_CH3_CCR,  EXTI_CONFIG_PORTA}, // D8/PA10
-        {GPIOB_BASE,  7, ADC_INVALID, TIMER4_CH2_CCR,  EXTI_CONFIG_PORTB}, // D9/PB7
-        {GPIOA_BASE,  4,        ADC4,  TIMER_INVALID,  EXTI_CONFIG_PORTA}, // D10/PA4
-        {GPIOA_BASE,  7,        ADC7, TIMER3_CH2_CCR,  EXTI_CONFIG_PORTA}, // D11/PA7
-        {GPIOA_BASE,  6,        ADC6, TIMER3_CH1_CCR,  EXTI_CONFIG_PORTA}, // D12/PA6
-        {GPIOA_BASE,  5,        ADC5,  TIMER_INVALID,  EXTI_CONFIG_PORTA}, // D13/PA5
-        {GPIOB_BASE,  8, ADC_INVALID, TIMER4_CH3_CCR,  EXTI_CONFIG_PORTB}, // D14/PB8
-        /* Little header  */
-        {GPIOC_BASE,  0,       ADC10,  TIMER_INVALID,  EXTI_CONFIG_PORTC}, // D15/PC0
-        {GPIOC_BASE,  1,       ADC11,  TIMER_INVALID,  EXTI_CONFIG_PORTC}, // D16/PC1
-        {GPIOC_BASE,  2,       ADC12,  TIMER_INVALID,  EXTI_CONFIG_PORTC}, // D17/PC2
-        {GPIOC_BASE,  3,       ADC13,  TIMER_INVALID,  EXTI_CONFIG_PORTC}, // D18/PC3
-        {GPIOC_BASE,  4,       ADC14,  TIMER_INVALID,  EXTI_CONFIG_PORTC}, // D19/PC4
-        {GPIOC_BASE,  5,       ADC15,  TIMER_INVALID,  EXTI_CONFIG_PORTC}, // D20/PC5
-        /* External header  */
-        {GPIOC_BASE, 13, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTC}, // D21/PC13
-        {GPIOC_BASE, 14, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTC}, // D22/PC14
-        {GPIOC_BASE, 15, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTC}, // D23/PC15
-        {GPIOB_BASE,  9, ADC_INVALID, TIMER4_CH4_CCR,  EXTI_CONFIG_PORTB}, // D24/PB9
-        {GPIOD_BASE,  2, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTD}, // D25/PD2
-        {GPIOC_BASE, 10, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTC}, // D26/PC10
-        {GPIOB_BASE,  0,        ADC8,  TIMER3_CH3_CCR, EXTI_CONFIG_PORTB}, // D27/PB0
-        {GPIOB_BASE,  1,        ADC9,  TIMER3_CH4_CCR, EXTI_CONFIG_PORTB}, // D28/PB1
-        {GPIOB_BASE, 10, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTB}, // D29/PB10
-        {GPIOB_BASE, 11, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTB}, // D30/PB11
-        {GPIOB_BASE, 12, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTB}, // D31/PB12
-        {GPIOB_BASE, 13, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTB}, // D32/PB13
-        {GPIOB_BASE, 14, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTB}, // D33/PB14
-        {GPIOB_BASE, 15, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTB}, // D34/PB15
-        {GPIOC_BASE,  6, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTC}, // D35/PC6
-        {GPIOC_BASE,  7, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTC}, // D36/PC7
-        {GPIOC_BASE,  8, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTC}, // D37/PC8
-        {GPIOC_BASE,  9, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTC}  // D38/PC9 (BUT)
+        /* D0/PA3 */
+        {GPIOA_BASE,  3,        ADC3, TIMER2_CH4_CCR,  EXTI_CONFIG_PORTA},
+        /* D1/PA2 */
+        {GPIOA_BASE,  2,        ADC2, TIMER2_CH3_CCR,  EXTI_CONFIG_PORTA},
+        /* D2/PA0 */
+        {GPIOA_BASE,  0,        ADC0, TIMER2_CH1_CCR,  EXTI_CONFIG_PORTA},
+        /* D3/PA1 */
+        {GPIOA_BASE,  1,        ADC1, TIMER2_CH2_CCR,  EXTI_CONFIG_PORTA},
+        /* D4/PB5 */
+        {GPIOB_BASE,  5, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTB},
+        /* D5/PB6 */
+        {GPIOB_BASE,  6, ADC_INVALID, TIMER4_CH1_CCR,  EXTI_CONFIG_PORTB},
+        /* D6/PA8 */
+        {GPIOA_BASE,  8, ADC_INVALID, TIMER1_CH1_CCR,  EXTI_CONFIG_PORTA},
+        /* D7/PA9 */
+        {GPIOA_BASE,  9, ADC_INVALID, TIMER1_CH2_CCR,  EXTI_CONFIG_PORTA},
+        /* D8/PA10 */
+        {GPIOA_BASE, 10, ADC_INVALID, TIMER1_CH3_CCR,  EXTI_CONFIG_PORTA},
+        /* D9/PB7 */
+        {GPIOB_BASE,  7, ADC_INVALID, TIMER4_CH2_CCR,  EXTI_CONFIG_PORTB},
+        /* D10/PA4 */
+        {GPIOA_BASE,  4,        ADC4,  TIMER_INVALID,  EXTI_CONFIG_PORTA},
+        /* D11/PA7 */
+        {GPIOA_BASE,  7,        ADC7, TIMER3_CH2_CCR,  EXTI_CONFIG_PORTA},
+        /* D12/PA6 */
+        {GPIOA_BASE,  6,        ADC6, TIMER3_CH1_CCR,  EXTI_CONFIG_PORTA},
+        /* D13/PA5 */
+        {GPIOA_BASE,  5,        ADC5,  TIMER_INVALID,  EXTI_CONFIG_PORTA},
+        /* D14/PB8 */
+        {GPIOB_BASE,  8, ADC_INVALID, TIMER4_CH3_CCR,  EXTI_CONFIG_PORTB},
+
+        /* Little header */
+
+        /* D15/PC0 */
+        {GPIOC_BASE,  0,       ADC10,  TIMER_INVALID,  EXTI_CONFIG_PORTC},
+        /* D16/PC1 */
+        {GPIOC_BASE,  1,       ADC11,  TIMER_INVALID,  EXTI_CONFIG_PORTC},
+        /* D17/PC2 */
+        {GPIOC_BASE,  2,       ADC12,  TIMER_INVALID,  EXTI_CONFIG_PORTC},
+        /* D18/PC3 */
+        {GPIOC_BASE,  3,       ADC13,  TIMER_INVALID,  EXTI_CONFIG_PORTC},
+        /* D19/PC4 */
+        {GPIOC_BASE,  4,       ADC14,  TIMER_INVALID,  EXTI_CONFIG_PORTC},
+        /* D20/PC5 */
+        {GPIOC_BASE,  5,       ADC15,  TIMER_INVALID,  EXTI_CONFIG_PORTC},
+
+        /* External header */
+
+        /* D21/PC13 */
+        {GPIOC_BASE, 13, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTC},
+        /* D22/PC14 */
+        {GPIOC_BASE, 14, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTC},
+        /* D23/PC15 */
+        {GPIOC_BASE, 15, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTC},
+        /* D24/PB9 */
+        {GPIOB_BASE,  9, ADC_INVALID, TIMER4_CH4_CCR,  EXTI_CONFIG_PORTB},
+        /* D25/PD2 */
+        {GPIOD_BASE,  2, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTD},
+        /* D26/PC10 */
+        {GPIOC_BASE, 10, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTC},
+        /* D27/PB0 */
+        {GPIOB_BASE,  0,        ADC8,  TIMER3_CH3_CCR, EXTI_CONFIG_PORTB},
+        /* D28/PB1 */
+        {GPIOB_BASE,  1,        ADC9,  TIMER3_CH4_CCR, EXTI_CONFIG_PORTB},
+        /* D29/PB10 */
+        {GPIOB_BASE, 10, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTB},
+        /* D30/PB11 */
+        {GPIOB_BASE, 11, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTB},
+        /* D31/PB12 */
+        {GPIOB_BASE, 12, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTB},
+        /* D32/PB13 */
+        {GPIOB_BASE, 13, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTB},
+        /* D33/PB14 */
+        {GPIOB_BASE, 14, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTB},
+        /* D34/PB15 */
+        {GPIOB_BASE, 15, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTB},
+        /* D35/PC6 */
+        {GPIOC_BASE,  6, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTC},
+        /* D36/PC7 */
+        {GPIOC_BASE,  7, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTC},
+        /* D37/PC8 */
+        {GPIOC_BASE,  8, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTC},
+        /* PC9 (BUT) */
+        {GPIOC_BASE,  9, ADC_INVALID,  TIMER_INVALID,  EXTI_CONFIG_PORTC}
     };
 
 #endif
 
-// LeafLabs Maple Native (prototype)
+/* LeafLabs Maple Native (prototype) */
 #ifdef BOARD_maple_native
 
     #define CYCLES_PER_MICROSECOND  72
@@ -127,65 +171,122 @@ typedef struct PinMapping {
 
     // TODO:
     static __attribute__ ((unused)) PinMapping PIN_MAP[NR_GPIO_PINS] = {
-        {GPIOA_BASE,  3,        ADC3, TIMER2_CH4_CCR}, // D0/PA3
-        {GPIOA_BASE,  2,        ADC2, TIMER2_CH3_CCR}, // D1/PA2
-        {GPIOA_BASE,  0,        ADC0, TIMER2_CH1_CCR}, // D2/PA0
-        {GPIOA_BASE,  1,        ADC1, TIMER2_CH2_CCR}, // D3/PA1
-        {GPIOB_BASE,  5, ADC_INVALID,  TIMER_INVALID}, // D4/PB5
-        {GPIOB_BASE,  6, ADC_INVALID, TIMER4_CH1_CCR}, // D5/PB6
-        {GPIOA_BASE,  8, ADC_INVALID, TIMER1_CH1_CCR}, // D6/PA8
-        {GPIOA_BASE,  9, ADC_INVALID, TIMER1_CH2_CCR}, // D7/PA9
-        {GPIOA_BASE, 10, ADC_INVALID, TIMER1_CH3_CCR}, // D8/PA10
-        {GPIOB_BASE,  7, ADC_INVALID, TIMER4_CH2_CCR}, // D9/PB7
-        {GPIOA_BASE,  4,        ADC4,  TIMER_INVALID}, // D10/PA4
-        {GPIOA_BASE,  7,        ADC7, TIMER3_CH2_CCR}, // D11/PA7
-        {GPIOA_BASE,  6,        ADC6, TIMER3_CH1_CCR}, // D12/PA6
-        {GPIOA_BASE,  5,        ADC5,  TIMER_INVALID}, // D13/PA5
-        {GPIOB_BASE,  8, ADC_INVALID, TIMER4_CH3_CCR}, // D14/PB8
+        /* D0/PA3 */
+        {GPIOA_BASE,  3,        ADC3, TIMER2_CH4_CCR},
+        /* D1/PA2 */
+        {GPIOA_BASE,  2,        ADC2, TIMER2_CH3_CCR},
+        /* D2/PA0 */
+        {GPIOA_BASE,  0,        ADC0, TIMER2_CH1_CCR},
+        /* D3/PA1 */
+        {GPIOA_BASE,  1,        ADC1, TIMER2_CH2_CCR},
+        /* D4/PB5 */
+        {GPIOB_BASE,  5, ADC_INVALID,  TIMER_INVALID},
+        /* D5/PB6 */
+        {GPIOB_BASE,  6, ADC_INVALID, TIMER4_CH1_CCR},
+        /* D6/PA8 */
+        {GPIOA_BASE,  8, ADC_INVALID, TIMER1_CH1_CCR},
+        /* D7/PA9 */
+        {GPIOA_BASE,  9, ADC_INVALID, TIMER1_CH2_CCR},
+        /* D8/PA10 */
+        {GPIOA_BASE, 10, ADC_INVALID, TIMER1_CH3_CCR},
+        /* D9/PB7 */
+        {GPIOB_BASE,  7, ADC_INVALID, TIMER4_CH2_CCR},
+        /* D10/PA4 */
+        {GPIOA_BASE,  4,        ADC4,  TIMER_INVALID},
+        /* D11/PA7 */
+        {GPIOA_BASE,  7,        ADC7, TIMER3_CH2_CCR},
+        /* D12/PA6 */
+        {GPIOA_BASE,  6,        ADC6, TIMER3_CH1_CCR},
+        /* D13/PA5 */
+        {GPIOA_BASE,  5,        ADC5,  TIMER_INVALID},
+        /* D14/PB8 */
+        {GPIOB_BASE,  8, ADC_INVALID, TIMER4_CH3_CCR},
+
         /* Little header  */
-        {GPIOC_BASE,  0,       ADC10,  TIMER_INVALID}, // D15/PC0
-        {GPIOC_BASE,  1,       ADC11,  TIMER_INVALID}, // D16/PC1
-        {GPIOC_BASE,  2,       ADC12,  TIMER_INVALID}, // D17/PC2
-        {GPIOC_BASE,  3,       ADC13,  TIMER_INVALID}, // D18/PC3
-        {GPIOC_BASE,  4,       ADC14,  TIMER_INVALID}, // D19/PC4
-        {GPIOC_BASE,  5,       ADC15,  TIMER_INVALID}, // D20/PC5
+
+        /* D15/PC0 */
+        {GPIOC_BASE,  0,       ADC10,  TIMER_INVALID},
+        /* D16/PC1 */
+        {GPIOC_BASE,  1,       ADC11,  TIMER_INVALID},
+        /* D17/PC2 */
+        {GPIOC_BASE,  2,       ADC12,  TIMER_INVALID},
+        /* D18/PC3 */
+        {GPIOC_BASE,  3,       ADC13,  TIMER_INVALID},
+        /* D19/PC4 */
+        {GPIOC_BASE,  4,       ADC14,  TIMER_INVALID},
+        /* D20/PC5 */
+        {GPIOC_BASE,  5,       ADC15,  TIMER_INVALID},
+
         /* External header  */
-        {GPIOC_BASE, 13, ADC_INVALID,  TIMER_INVALID}, // D21/PC13
-        {GPIOC_BASE, 14, ADC_INVALID,  TIMER_INVALID}, // D22/PC14
-        {GPIOC_BASE, 15, ADC_INVALID,  TIMER_INVALID}, // D23/PC15
-        {GPIOB_BASE,  9, ADC_INVALID, TIMER4_CH4_CCR}, // D24/PB9
-        {GPIOD_BASE,  2, ADC_INVALID,  TIMER_INVALID}, // D25/PD2
-        {GPIOC_BASE, 10, ADC_INVALID,  TIMER_INVALID}, // D26/PC10
-        {GPIOB_BASE,  0,        ADC8,  TIMER3_CH3_CCR}, // D27/PB0
-        {GPIOB_BASE,  1,        ADC9,  TIMER3_CH4_CCR}, // D28/PB1
-        {GPIOB_BASE, 10, ADC_INVALID,  TIMER_INVALID}, // D29/PB10
-        {GPIOB_BASE, 11, ADC_INVALID,  TIMER_INVALID}, // D30/PB11
-        {GPIOB_BASE, 12, ADC_INVALID,  TIMER_INVALID}, // D31/PB12
-        {GPIOB_BASE, 13, ADC_INVALID,  TIMER_INVALID}, // D32/PB13
-        {GPIOB_BASE, 14, ADC_INVALID,  TIMER_INVALID}, // D33/PB14
-        {GPIOB_BASE, 15, ADC_INVALID,  TIMER_INVALID}, // D34/PB15
-        {GPIOC_BASE,  6, ADC_INVALID,  TIMER_INVALID}, // D35/PC6
-        {GPIOC_BASE,  7, ADC_INVALID,  TIMER_INVALID}, // D36/PC7
-        {GPIOC_BASE,  8, ADC_INVALID,  TIMER_INVALID}, // D37/PC8
-        {GPIOC_BASE,  9, ADC_INVALID,  TIMER_INVALID}  // D38/PC9 (BUT)
+
+        /* D21/PC13 */
+        {GPIOC_BASE, 13, ADC_INVALID,  TIMER_INVALID},
+        /* D22/PC14 */
+        {GPIOC_BASE, 14, ADC_INVALID,  TIMER_INVALID},
+        /* D23/PC15 */
+        {GPIOC_BASE, 15, ADC_INVALID,  TIMER_INVALID},
+        /* D24/PB9 */
+        {GPIOB_BASE,  9, ADC_INVALID, TIMER4_CH4_CCR},
+        /* D25/PD2 */
+        {GPIOD_BASE,  2, ADC_INVALID,  TIMER_INVALID},
+        /* D26/PC10 */
+        {GPIOC_BASE, 10, ADC_INVALID,  TIMER_INVALID},
+        /* D27/PB0 */
+        {GPIOB_BASE,  0,        ADC8,  TIMER3_CH3_CCR},
+        /* D28/PB1 */
+        {GPIOB_BASE,  1,        ADC9,  TIMER3_CH4_CCR},
+        /* D29/PB10 */
+        {GPIOB_BASE, 10, ADC_INVALID,  TIMER_INVALID},
+        /* D30/PB11 */
+        {GPIOB_BASE, 11, ADC_INVALID,  TIMER_INVALID},
+        /* D31/PB12 */
+        {GPIOB_BASE, 12, ADC_INVALID,  TIMER_INVALID},
+        /* D32/PB13 */
+        {GPIOB_BASE, 13, ADC_INVALID,  TIMER_INVALID},
+        /* D33/PB14 */
+        {GPIOB_BASE, 14, ADC_INVALID,  TIMER_INVALID},
+        /* D34/PB15 */
+        {GPIOB_BASE, 15, ADC_INVALID,  TIMER_INVALID},
+        /* D35/PC6 */
+        {GPIOC_BASE,  6, ADC_INVALID,  TIMER_INVALID},
+        /* D36/PC7 */
+        {GPIOC_BASE,  7, ADC_INVALID,  TIMER_INVALID},
+        /* D37/PC8 */
+        {GPIOC_BASE,  8, ADC_INVALID,  TIMER_INVALID},
+        /* PC9 (BUT) */
+        {GPIOC_BASE,  9, ADC_INVALID,  TIMER_INVALID}
     };
 
-    static __attribute__ ((unused)) ExtiInfo PIN_TO_EXTI_CHANNEL[NR_GPIO_PINS] =
+    static __attribute__((unused)) ExtiInfo PIN_TO_EXTI_CHANNEL[NR_GPIO_PINS] =
     {
-        {EXTI3,  EXTI_CONFIG_PORTA},      // D0/PA3
-        {EXTI2,  EXTI_CONFIG_PORTA},      // D1/PA2
-        {EXTI0,  EXTI_CONFIG_PORTA},      // D2/PA0
-        {EXTI1,  EXTI_CONFIG_PORTA},      // D3/PA1
-        {EXTI5,  EXTI_CONFIG_PORTB},      // D4/PB5
-        {EXTI6,  EXTI_CONFIG_PORTB},      // D5/PB6
-        {EXTI8,  EXTI_CONFIG_PORTA},      // D6/PA8
-        {EXTI9,  EXTI_CONFIG_PORTA},      // D7/PA9
-        {EXTI10, EXTI_CONFIG_PORTA},      // D8/PA10
-        {EXTI7,  EXTI_CONFIG_PORTB},      // D9/PB7
-        {EXTI4,  EXTI_CONFIG_PORTA},      // D10/PA4
-        {EXTI7,  EXTI_CONFIG_PORTA},      // D11/PA7
-        {EXTI6,  EXTI_CONFIG_PORTA},      // D12/PA6
-        {EXTI5,  EXTI_CONFIG_PORTA},      // D13/PA5
+        /* D0/PA3 */
+        {EXTI3,  EXTI_CONFIG_PORTA},
+        /* D1/PA2 */
+        {EXTI2,  EXTI_CONFIG_PORTA},
+        /* D2/PA0 */
+        {EXTI0,  EXTI_CONFIG_PORTA},
+        /* D3/PA1 */
+        {EXTI1,  EXTI_CONFIG_PORTA},
+        /* D4/PB5 */
+        {EXTI5,  EXTI_CONFIG_PORTB},
+        /* D5/PB6 */
+        {EXTI6,  EXTI_CONFIG_PORTB},
+        /* D6/PA8 */
+        {EXTI8,  EXTI_CONFIG_PORTA},
+        /* D7/PA9 */
+        {EXTI9,  EXTI_CONFIG_PORTA},
+        /* D8/PA10 */
+        {EXTI10, EXTI_CONFIG_PORTA},
+        /* D9/PB7 */
+        {EXTI7,  EXTI_CONFIG_PORTB},
+        /* D10/PA4 */
+        {EXTI4,  EXTI_CONFIG_PORTA},
+        /* D11/PA7 */
+        {EXTI7,  EXTI_CONFIG_PORTA},
+        /* D12/PA6 */
+        {EXTI6,  EXTI_CONFIG_PORTA},
+        /* D13/PA5 */
+        {EXTI5,  EXTI_CONFIG_PORTA},
     };
 #endif
 
diff --git a/wirish/ext_interrupts.c b/wirish/ext_interrupts.c
index 5009d75..f02cdc5 100644
--- a/wirish/ext_interrupts.c
+++ b/wirish/ext_interrupts.c
@@ -1,4 +1,4 @@
-/* *****************************************************************************
+/******************************************************************************
  * The MIT License
  *
  * Copyright (c) 2010 Perry Hung.
@@ -20,7 +20,7 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
- * ****************************************************************************/
+ *****************************************************************************/
 
 /**
  *  @file ext_interrupts.c
@@ -44,7 +44,8 @@
  */
 void attachInterrupt(uint8 pin, voidFuncPtr handler, uint32 mode) {
     uint8 outMode;
-    /* Parameter checking  */
+
+    /* Parameter checking */
     if (pin >= NR_GPIO_PINS) {
         return;
     }
@@ -68,9 +69,9 @@ void attachInterrupt(uint8 pin, voidFuncPtr handler, uint32 mode) {
     }
 
     exti_attach_interrupt(PIN_MAP[pin].exti_port,
-            PIN_MAP[pin].pin,
-            handler,
-            mode);
+                          PIN_MAP[pin].pin,
+                          handler,
+                          mode);
 
     return;
 }
diff --git a/wirish/ext_interrupts.h b/wirish/ext_interrupts.h
index 62f31bb..fef8c8f 100644
--- a/wirish/ext_interrupts.h
+++ b/wirish/ext_interrupts.h
@@ -1,4 +1,4 @@
-/* *****************************************************************************
+/******************************************************************************
  * The MIT License
  *
  * Copyright (c) 2010 Perry Hung.
@@ -20,7 +20,7 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
- * ****************************************************************************/
+ *****************************************************************************/
 
 /**
  *  @file ext_interrupts.h
diff --git a/wirish/io.h b/wirish/io.h
index 4aa1eef..647e79c 100644
--- a/wirish/io.h
+++ b/wirish/io.h
@@ -1,4 +1,4 @@
-/* *****************************************************************************
+/******************************************************************************
  * The MIT License
  *
  * Copyright (c) 2010 Perry Hung.
@@ -20,12 +20,12 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
- * ****************************************************************************/
+ *****************************************************************************/
 
 /**
  *  @file io.h
  *
- *  @brief 
+ *  @brief Arduino-compatible digital pin I/O interface.
  */
 
 #ifndef _IO_H
@@ -38,7 +38,6 @@
 extern "C"{
 #endif
 
-
 typedef enum WiringPinMode {
     OUTPUT,
     OUTPUT_OPEN_DRAIN,
@@ -85,7 +84,7 @@ uint32 digitalRead(uint8);
  * to INPUT_ANALOG
  * analogRead(pin)
  *     pin -> {A0-A16}
- *     */
+ */
 uint32 analogRead(uint8);
 
 #ifdef __cplusplus
diff --git a/wirish/pwm.c b/wirish/pwm.c
index 995e2c7..2f555ab 100644
--- a/wirish/pwm.c
+++ b/wirish/pwm.c
@@ -1,4 +1,4 @@
-/* *****************************************************************************
+/******************************************************************************
  * The MIT License
  *
  * Copyright (c) 2010 Perry Hung.
@@ -20,10 +20,10 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
- * ****************************************************************************/
+ *****************************************************************************/
 
 /**
- *  @brief 
+ *  @brief Arduino-compatible PWM implementation.
  */
 
 #include "wirish.h"
@@ -40,8 +40,9 @@ void pwmWrite(uint8 pin, uint16 duty_cycle) {
 
     ccr = PIN_MAP[pin].timer_channel;
 
-    if (ccr == TIMER_INVALID)
+    if (ccr == TIMER_INVALID) {
         return;
+    }
 
     timer_pwm_write_ccr(ccr, duty_cycle);
 }
diff --git a/wirish/pwm.h b/wirish/pwm.h
index 927b685..fe170cd 100644
--- a/wirish/pwm.h
+++ b/wirish/pwm.h
@@ -1,4 +1,4 @@
-/* *****************************************************************************
+/******************************************************************************
  * The MIT License
  *
  * Copyright (c) 2010 Perry Hung.
@@ -20,12 +20,12 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
- * ****************************************************************************/
+ *****************************************************************************/
 
 /**
  *  @file pwm.h
  *
- *  @brief 
+ *  @brief Arduino-compatible PWM interface.
  */
 
 #ifndef _PWM_H
diff --git a/wirish/time.c b/wirish/time.c
index eaa3c9e..3a48197 100644
--- a/wirish/time.c
+++ b/wirish/time.c
@@ -1,4 +1,4 @@
-/* *****************************************************************************
+/******************************************************************************
  * The MIT License
  *
  * Copyright (c) 2010 Perry Hung.
@@ -20,30 +20,30 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
- * ****************************************************************************/
+ *****************************************************************************/
 
 /**
- *  @brief
+ *  @brief Delay implementation.
  */
 
 #include "libmaple.h"
 #include "systick.h"
 #include "time.h"
 
-void delay(unsigned long ms)
-{
-   uint32 i;
-   for (i = 0; i < ms; i++) {
-      delayMicroseconds(1000);
-   }
+void delay(unsigned long ms) {
+    uint32 i;
+    for (i = 0; i < ms; i++) {
+        delayMicroseconds(1000);
+    }
 }
 
 void delayMicroseconds(uint32 us) {
-    // So (2^32)/12 micros max, or less than 6 minutes
+    /* So (2^32)/12 micros max, or less than 6 minutes */
     us *= 12;
 
     /* fudge for function call overhead  */
     us--;
+    int x = 4;
     asm volatile("   mov r0, %[us]          \n\t"
                  "1: subs r0, #1            \n\t"
                  "   bhi 1b                 \n\t"
diff --git a/wirish/time.h b/wirish/time.h
index ad39057..fad47a4 100644
--- a/wirish/time.h
+++ b/wirish/time.h
@@ -1,4 +1,4 @@
-/* *****************************************************************************
+/******************************************************************************
  * The MIT License
  *
  * Copyright (c) 2010 Perry Hung.
@@ -20,10 +20,10 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
- * ****************************************************************************/
+ *****************************************************************************/
 
 /**
- *  @brief
+ *  @brief Timing and delay functions.
  */
 
 #ifndef _TIME_H
@@ -43,28 +43,28 @@ extern volatile uint32 systick_timer_millis;
 
 /* time in milliseconds since boot  */
 static inline uint32 millis(void) {
-   return systick_timer_millis;
+    return systick_timer_millis;
 }
 
 /* Time in microseconds since boot  */
 static inline uint32 micros(void) {
-   uint32 ms;
-   uint32 cycle_cnt;
-   uint32 res;
+    uint32 ms;
+    uint32 cycle_cnt;
+    uint32 res;
 
-   nvic_globalirq_disable();
+    nvic_globalirq_disable();
 
-   cycle_cnt = systick_get_count();
-   ms = millis();
+    cycle_cnt = systick_get_count();
+    ms = millis();
 
-   nvic_globalirq_enable();
+    nvic_globalirq_enable();
 
-   /* MAPLE_RELOAD_VAL is 1 less than the number of cycles it actually
-      takes to complete a systick reload */
-   res = (ms * US_PER_MS) +
-       (MAPLE_RELOAD_VAL + 1 - cycle_cnt)/CYCLES_PER_MICROSECOND;
+    /* MAPLE_RELOAD_VAL is 1 less than the number of cycles it actually
+       takes to complete a systick reload */
+    res = (ms * US_PER_MS) +
+        (MAPLE_RELOAD_VAL + 1 - cycle_cnt)/CYCLES_PER_MICROSECOND;
 
-   return res;
+    return res;
 }
 
 void delay(unsigned long ms);
diff --git a/wirish/usb_serial.cpp b/wirish/usb_serial.cpp
index fafdf49..405220a 100644
--- a/wirish/usb_serial.cpp
+++ b/wirish/usb_serial.cpp
@@ -1,4 +1,4 @@
-/* *****************************************************************************
+/******************************************************************************
  * The MIT License
  *
  * Copyright (c) 2010 Perry Hung.
@@ -20,10 +20,10 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
- * ****************************************************************************/
+ *****************************************************************************/
 
 /**
- *  @brief wirish usb class for easy goin communication, uses libmaple's
+ *  @brief Wirish USB class for easy communication, uses libmaple's
  *  virtual com port implementation
  */
 
@@ -49,8 +49,10 @@ void USBSerial::write(uint8 ch) {
     if(!(usbIsConnected() && usbIsConfigured())) {
         return;
     }
+
     uint16 status = 0;
     uint32 start = millis();
+
     while(status == 0 && (millis() - start <= USB_TIMEOUT)) {
         status = usbSendBytes(&ch, 1);
     }
@@ -60,13 +62,15 @@ void USBSerial::write(const char *str) {
     if(!(usbIsConnected() && usbIsConfigured())) {
         return;
     }
+
     uint32 len = strlen(str);
     uint16 status = 0;
     uint16 oldstatus = 0;
     uint32 start = millis();
+
     while(status < len && (millis() - start < USB_TIMEOUT)) {
         status += usbSendBytes((uint8*)str+status, len-status);
-        if(oldstatus != status) 
+        if(oldstatus != status)
             start = millis();
         oldstatus = status;
     }
@@ -76,52 +80,55 @@ void USBSerial::write(void *buf, uint32 size) {
     if(!(usbIsConnected() && usbIsConfigured())) {
         return;
     }
+
     if (!buf) {
         return;
     }
+
     uint16 status = 0;
     uint16 oldstatus = 0;
     uint32 start = millis();
+
     while(status < size && (millis() - start < USB_TIMEOUT)) {
         status += usbSendBytes((uint8*)buf+status, size-status);
-        if(oldstatus != status) 
+        if(oldstatus != status)
             start = millis();
         oldstatus = status;
     }
 }
 
 uint32 USBSerial::available(void) {
-   return usbBytesAvailable();
+    return usbBytesAvailable();
 }
 
 uint32 USBSerial::read(void *buf, uint32 len) {
-   if (!buf) {
-      return 0;
-   }
+    if (!buf) {
+        return 0;
+    }
 
-   return usbReceiveBytes((uint8*)buf, len);
+    return usbReceiveBytes((uint8*)buf, len);
 }
 
 uint8 USBSerial::read(void) {
-   uint8 ch;
-   usbReceiveBytes(&ch, 1);
-   return ch;
+    uint8 ch;
+    usbReceiveBytes(&ch, 1);
+    return ch;
 }
 
 uint8 USBSerial::pending(void) {
-   return usbGetPending();
+    return usbGetPending();
 }
 
 uint8 USBSerial::getDTR(void) {
-   return usbGetDTR();
+    return usbGetDTR();
 }
 
 uint8 USBSerial::getRTS(void) {
-   return usbGetRTS();
+    return usbGetRTS();
 }
 
 uint8 USBSerial::isConnected(void) {
-   return (usbIsConnected() && usbIsConfigured());
+    return (usbIsConnected() && usbIsConfigured());
 }
 
 USBSerial SerialUSB;
diff --git a/wirish/usb_serial.h b/wirish/usb_serial.h
index 7c87c04..c228837 100644
--- a/wirish/usb_serial.h
+++ b/wirish/usb_serial.h
@@ -1,4 +1,4 @@
-/* *****************************************************************************
+/******************************************************************************
  * The MIT License
  *
  * Copyright (c) 2010 Perry Hung.
@@ -20,11 +20,11 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
- * ****************************************************************************/
+ *****************************************************************************/
 
 /**
- *  @brief wirish usb class for easy goin communication, uses libmaple's
- *  virtual com port implementation
+ * @brief wirish usb class for easy goin communication, uses libmaple's
+ * virtual com port implementation
  */
 
 #ifndef _USB_SERIAL_H_
@@ -33,25 +33,25 @@
 #include "Print.h"
 
 class USBSerial : public Print {
-   public:
-      USBSerial(void);
+public:
+    USBSerial(void);
 
-      void begin(void);
-      void end(void);
+    void begin(void);
+    void end(void);
 
-      uint32 available(void);
+    uint32 available(void);
 
-      uint32 read(void *buf, uint32 len);
-      uint8  read(void);
+    uint32 read(void *buf, uint32 len);
+    uint8  read(void);
 
-      void   write(uint8);
-      void   write(const char *str);
-      void   write(void *, uint32);
+    void write(uint8);
+    void write(const char *str);
+    void write(void *, uint32);
 
-      uint8  getRTS();
-      uint8  getDTR();
-      uint8  isConnected();
-      uint8  pending();
+    uint8 getRTS();
+    uint8 getDTR();
+    uint8 isConnected();
+    uint8 pending();
 };
 
 extern USBSerial SerialUSB;
diff --git a/wirish/wirish.c b/wirish/wirish.c
index 5407131..0abec41 100644
--- a/wirish/wirish.c
+++ b/wirish/wirish.c
@@ -1,4 +1,4 @@
-/* *****************************************************************************
+/******************************************************************************
  * The MIT License
  *
  * Copyright (c) 2010 Perry Hung.
@@ -20,17 +20,16 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
- * ****************************************************************************/
+ *****************************************************************************/
 
 /**
- *  @brief generic maple board bring up:
+ * @brief generic maple board bring up:
  *
- *  By default, we bring up all maple boards running on the stm32 to 72mhz,
- *  clocked off the PLL, driven by the 8MHz external crystal.
- *
- *  AHB and APB2 are clocked at 72MHz
- *  APB1 is clocked at 36MHz
+ * By default, we bring up all maple boards running on the stm32 to 72mhz,
+ * clocked off the PLL, driven by the 8MHz external crystal.
  *
+ * AHB and APB2 are clocked at 72MHz
+ * APB1 is clocked at 36MHz
  */
 
 #include "wirish.h"
@@ -44,35 +43,35 @@
 #include "flash.h"
 
 void init(void) {
-   /* make sure the flash is ready before spinning the high speed clock up */
-   flash_enable_prefetch();
-   flash_set_latency(FLASH_WAIT_STATE_2);
+    /* make sure the flash is ready before spinning the high speed clock up */
+    flash_enable_prefetch();
+    flash_set_latency(FLASH_WAIT_STATE_2);
 
-   #if NR_FSMC > 0
-   fsmc_native_sram_init();
-   #endif
+#if NR_FSMC > 0
+    fsmc_native_sram_init();
+#endif
 
-   #if NR_DAC_PINS > 0
-   dac_init();
-   #endif
+#if NR_DAC_PINS > 0
+    dac_init();
+#endif
 
-   /* initialize clocks  */
-   rcc_clk_init(RCC_CLKSRC_PLL, RCC_PLLSRC_HSE, RCC_PLLMUL_9);
-   rcc_set_prescaler(RCC_PRESCALER_AHB, RCC_AHB_SYSCLK_DIV_1);
-   rcc_set_prescaler(RCC_PRESCALER_APB1, RCC_APB1_HCLK_DIV_2);
-   rcc_set_prescaler(RCC_PRESCALER_APB2, RCC_APB2_HCLK_DIV_1);
+    /* initialize clocks  */
+    rcc_clk_init(RCC_CLKSRC_PLL, RCC_PLLSRC_HSE, RCC_PLLMUL_9);
+    rcc_set_prescaler(RCC_PRESCALER_AHB, RCC_AHB_SYSCLK_DIV_1);
+    rcc_set_prescaler(RCC_PRESCALER_APB1, RCC_APB1_HCLK_DIV_2);
+    rcc_set_prescaler(RCC_PRESCALER_APB2, RCC_APB2_HCLK_DIV_1);
 
-   nvic_init();
-   systick_init(MAPLE_RELOAD_VAL);
-   gpio_init();
-   adc_init();
-   timer_init(TIMER1, 1);
-   timer_init(TIMER2, 1);
-   timer_init(TIMER3, 1);
-   timer_init(TIMER4, 1);
-   #if NR_TIMERS >= 8
-   timer_init(TIMER5, 1);
-   timer_init(TIMER8, 1);
-   #endif
-   setupUSB();
+    nvic_init();
+    systick_init(MAPLE_RELOAD_VAL);
+    gpio_init();
+    adc_init();
+    timer_init(TIMER1, 1);
+    timer_init(TIMER2, 1);
+    timer_init(TIMER3, 1);
+    timer_init(TIMER4, 1);
+#if NR_TIMERS >= 8
+    timer_init(TIMER5, 1);
+    timer_init(TIMER8, 1);
+#endif
+    setupUSB();
 }
diff --git a/wirish/wirish.h b/wirish/wirish.h
index 7ede77c..c1c46cb 100644
--- a/wirish/wirish.h
+++ b/wirish/wirish.h
@@ -1,4 +1,4 @@
-/* *****************************************************************************
+/******************************************************************************
  * The MIT License
  *
  * Copyright (c) 2010 Perry Hung.
@@ -20,14 +20,14 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
- * ****************************************************************************/
+ *****************************************************************************/
+
 /**
  * @brief Main include file for the Wirish core.
  *
  * Includes various Arduino wiring macros and bit defines
  */
 
-
 #ifndef _WIRISH_H_
 #define _WIRISH_H_
 
@@ -62,14 +62,14 @@ extern "C"{
 #define LSBFIRST 0
 #define MSBFIRST 1
 
-#define lowByte(w)                       ((w) & 0xff)
-#define highByte(w)                      ((w) >> 8)
-#define bitRead(value, bit)              (((value) >> (bit)) & 0x01)
-#define bitSet(value, bit)               ((value) |= (1UL << (bit)))
-#define bitClear(value, bit)             ((value) &= ~(1UL << (bit)))
-#define bitWrite(value, bit, bitvalue)   (bitvalue ? bitSet(value, bit) :      \
-                                                     bitClear(value, bit))
-#define bit(b)                           (1UL << (b))
+#define lowByte(w)                     ((w) & 0xff)
+#define highByte(w)                    ((w) >> 8)
+#define bitRead(value, bit)            (((value) >> (bit)) & 0x01)
+#define bitSet(value, bit)             ((value) |= (1UL << (bit)))
+#define bitClear(value, bit)           ((value) &= ~(1UL << (bit)))
+#define bitWrite(value, bit, bitvalue) (bitvalue ? bitSet(value, bit) : \
+                                                   bitClear(value, bit))
+#define bit(b)                         (1UL << (b))
 
 typedef uint8 boolean;
 typedef uint8 byte;
diff --git a/wirish/wirish_analog.c b/wirish/wirish_analog.c
index 1b911bc..3c63342 100644
--- a/wirish/wirish_analog.c
+++ b/wirish/wirish_analog.c
@@ -1,4 +1,4 @@
-/* *****************************************************************************
+/******************************************************************************
  * The MIT License
  *
  * Copyright (c) 2010 Perry Hung.
@@ -20,22 +20,22 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
- * ****************************************************************************/
+ *****************************************************************************/
 
 /**
- *  @brief 
+ *  @brief Arduino-compatible ADC implementation.
  */
 
 #include "libmaple.h"
 #include "wirish.h"
 #include "io.h"
 
-/* Assumes that the ADC has been initialized and
- * that the pin is set to ANALOG_INPUT */
+/* Assumes that the ADC has been initialized and that the pin is set
+ * to ANALOG_INPUT */
 uint32 analogRead(uint8 pin) {
     if(PIN_MAP[pin].adc == ADC_INVALID) {
         return 0;
-    } 
+    }
 
     return adc_read(PIN_MAP[pin].adc);
 }
diff --git a/wirish/wirish_digital.c b/wirish/wirish_digital.c
index 9dd46ed..f4868da 100644
--- a/wirish/wirish_digital.c
+++ b/wirish/wirish_digital.c
@@ -1,4 +1,4 @@
-/* *****************************************************************************
+/******************************************************************************
  * The MIT License
  *
  * Copyright (c) 2010 Perry Hung.
@@ -20,10 +20,10 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
- * ****************************************************************************/
+ *****************************************************************************/
 
 /**
- *  @brief 
+ *  @brief Arduino-compatible digital I/O implementation.
  */
 
 #include "wirish.h"
@@ -32,8 +32,9 @@
 void pinMode(uint8 pin, WiringPinMode mode) {
     uint8 outputMode;
 
-    if (pin >= NR_GPIO_PINS)
+    if (pin >= NR_GPIO_PINS) {
         return;
+    }
 
     switch(mode) {
     case OUTPUT:
@@ -71,14 +72,17 @@ void pinMode(uint8 pin, WiringPinMode mode) {
 
 
 uint32 digitalRead(uint8 pin) {
-    if (pin >= NR_GPIO_PINS)
+    if (pin >= NR_GPIO_PINS) {
         return 0;
+    }
+
     return gpio_read_bit(PIN_MAP[pin].port, PIN_MAP[pin].pin);
 }
 
 void digitalWrite(uint8 pin, uint8 val) {
-    if (pin >= NR_GPIO_PINS)
+    if (pin >= NR_GPIO_PINS) {
         return;
+    }
 
     gpio_write_bit(PIN_MAP[pin].port, PIN_MAP[pin].pin, val);
 }
diff --git a/wirish/wirish_math.cpp b/wirish/wirish_math.cpp
index 0d907c4..12a21c3 100644
--- a/wirish/wirish_math.cpp
+++ b/wirish/wirish_math.cpp
@@ -1,54 +1,54 @@
 /*
-  Modified by LeafLabs, LLC.
-
-  Part of the Wiring project - http://wiring.org.co
-  Copyright (c) 2004-06 Hernando Barragan
-  Modified 13 August 2006, David A. Mellis for Arduino - http://www.arduino.cc/
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of the GNU Lesser General
-  Public License along with this library; if not, write to the
-  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
-  Boston, MA  02111-1307  USA
-
-  $Id$
-*/
+ * Modified by LeafLabs, LLC.
+ *
+ * Part of the Wiring project - http://wiring.org.co Copyright (c)
+ * 2004-06 Hernando Barragan Modified 13 August 2006, David A. Mellis
+ * for Arduino - http://www.arduino.cc/
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
 
 #include <stdlib.h>
 #include "math.h"
 
 void randomSeed(unsigned int seed) {
-  if (seed != 0) {
-    srand(seed);
-  }
+    if (seed != 0) {
+        srand(seed);
+    }
 }
 
 long random(long howbig) {
-  if (howbig == 0) {
-    return 0;
-  }
-  return rand() % howbig;
+    if (howbig == 0) {
+        return 0;
+    }
+
+    return rand() % howbig;
 }
 
 long random(long howsmall, long howbig) {
-  if (howsmall >= howbig) {
-    return howsmall;
-  }
-  long diff = howbig - howsmall;
-  return random(diff) + howsmall;
+    if (howsmall >= howbig) {
+        return howsmall;
+    }
+
+    long diff = howbig - howsmall;
+    return random(diff) + howsmall;
 }
 
 long map(long x, long in_min, long in_max, long out_min, long out_max) {
-  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
+    return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
 }
 
 
diff --git a/wirish/wirish_math.h b/wirish/wirish_math.h
index 8746d01..4543c1b 100644
--- a/wirish/wirish_math.h
+++ b/wirish/wirish_math.h
@@ -1,4 +1,4 @@
-/* *****************************************************************************
+/******************************************************************************
  * The MIT License
  *
  * Copyright (c) 2010 Perry Hung.
@@ -20,7 +20,7 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
- * ****************************************************************************/
+ *****************************************************************************/
 
 #ifndef _WIRING_MATH_H_
 #define _WIRING_MATH_H_
@@ -34,11 +34,11 @@ long random(long);
 long random(long, long);
 long map(long, long, long, long, long);
 
-#define PI              3.1415926535897932384626433832795
-#define HALF_PI         1.5707963267948966192313216916398
-#define TWO_PI          6.283185307179586476925286766559
-#define DEG_TO_RAD      0.017453292519943295769236907684886
-#define RAD_TO_DEG      57.295779513082320876798154814105
+#define PI          3.1415926535897932384626433832795
+#define HALF_PI     1.5707963267948966192313216916398
+#define TWO_PI      6.283185307179586476925286766559
+#define DEG_TO_RAD  0.017453292519943295769236907684886
+#define RAD_TO_DEG 57.295779513082320876798154814105
 
 #define min(a,b)                ((a)<(b)?(a):(b))
 #define max(a,b)                ((a)>(b)?(a):(b))
@@ -52,7 +52,7 @@ long map(long, long, long, long, long);
 #ifdef abs
 #undef abs
 #endif
-#define abs(x)                  (((x) > 0)  ?  (x) : -(unsigned)(x))
+#define abs(x) (((x) > 0) ? (x) : -(unsigned)(x))
 
 #endif
 
diff --git a/wirish/wirish_shift.c b/wirish/wirish_shift.c
index 884b560..f67364d 100644
--- a/wirish/wirish_shift.c
+++ b/wirish/wirish_shift.c
@@ -1,38 +1,38 @@
 /*
-  wiring_shift.c - shiftOut() function
-  Part of Arduino - http://www.arduino.cc/
-
-  Copyright (c) 2005-2006 David A. Mellis
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of the GNU Lesser General
-  Public License along with this library; if not, write to the
-  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
-  Boston, MA  02111-1307  USA
-
-  $Id: wiring.c 248 2007-02-03 15:36:30Z mellis $
-*/
+ * wiring_shift.c - shiftOut() function
+ * Part of Arduino - http://www.arduino.cc/
+ *
+ * Copyright (c) 2005-2006 David A. Mellis
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ *
+ * $Id: wiring.c 248 2007-02-03 15:36:30Z mellis $
+ */
 
 #include "wirish.h"
 
-void shiftOut(uint8 dataPin, uint8 clockPin, uint8 bitOrder, uint8 val)
-{
+void shiftOut(uint8 dataPin, uint8 clockPin, uint8 bitOrder, uint8 val) {
     int i;
 
-    for (i = 0; i < 8; i++)  {
-        if (bitOrder == LSBFIRST)
+    for (i = 0; i < 8; i++) {
+        if (bitOrder == LSBFIRST) {
             digitalWrite(dataPin, !!(val & (1 << i)));
-        else
+        } else {
             digitalWrite(dataPin, !!(val & (1 << (7 - i))));
+        }
 
         digitalWrite(clockPin, HIGH);
         digitalWrite(clockPin, LOW);