1 files changed, 42 insertions, 14 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);
 }