diff --git a/chronos/drivers/display.c b/chronos/drivers/display.c
index 1473703e4b1d..39774279b388 100644
--- a/chronos/drivers/display.c
+++ b/chronos/drivers/display.c
@@ -1,514 +1,382 @@
-// *************************************************************************************************
-//
-//	Copyright (C) 2009 Texas Instruments Incorporated - http://www.ti.com/ 
-//	 
-//	 
-//	  Redistribution and use in source and binary forms, with or without 
-//	  modification, are permitted provided that the following conditions 
-//	  are met:
-//	
-//	    Redistributions of source code must retain the above copyright 
-//	    notice, this list of conditions and the following disclaimer.
-//	 
-//	    Redistributions in binary form must reproduce the above copyright
-//	    notice, this list of conditions and the following disclaimer in the 
-//	    documentation and/or other materials provided with the   
-//	    distribution.
-//	 
-//	    Neither the name of Texas Instruments Incorporated nor the names of
-//	    its contributors may be used to endorse or promote products derived
-//	    from this software without specific prior written permission.
-//	
-//	  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
-//	  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
-//	  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-//	  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
-//	  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
-//	  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
-//	  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-//	  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-//	  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
-//	  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
-//	  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// *************************************************************************************************
-// Display functions.
-// *************************************************************************************************
-
-
-// *************************************************************************************************
-// Include section
-
-// system
+/* *************************************************************************************************
+ *
+ *	Copyright (C) 2009 Texas Instruments Incorporated - http://www.ti.com/ 
+ *	 
+ *	 
+ *	  Redistribution and use in source and binary forms, with or without 
+ *	  modification, are permitted provided that the following conditions 
+ *	  are met:
+ *	
+ *	    Redistributions of source code must retain the above copyright 
+ *	    notice, this list of conditions and the following disclaimer.
+ *	 
+ *	    Redistributions in binary form must reproduce the above copyright
+ *	    notice, this list of conditions and the following disclaimer in the 
+ *	    documentation and/or other materials provided with the   
+ *	    distribution.
+ *	 
+ *	    Neither the name of Texas Instruments Incorporated nor the names of
+ *	    its contributors may be used to endorse or promote products derived
+ *	    from this software without specific prior written permission.
+ *	
+ *	  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ *	  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ *	  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *	  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+ *	  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ *	  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ *	  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *	  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *	  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ *	  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ *	  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * *************************************************************************************************
+ * Basic display functions.
+ * ************************************************************************************************/
+
+/* *************************************************************************************************
+ * Include section
+ */
+
+/* system */
 #include <string.h>
 
-// driver
+/* driver */
 #include <cc430x613x.h>
 #include <display.h>
 
 
-// *************************************************************************************************
-// Prototypes section
+/**************************************************************************************************
+ * Prototypes section */
 void write_lcd_mem(uint8_t *lcdmem, uint8_t bits, uint8_t bitmask, uint8_t state);
 void clear_line(uint8_t line);
 void display_symbol(uint8_t symbol, uint8_t mode);
 
-// *************************************************************************************************
-// Defines section
+/* *************************************************************************************************
+ * Global Variable section */
 
-
-
-// *************************************************************************************************
-// Global Variable section
-
-// Display flags
+/* Display flags */
 volatile s_display_flags display;
 
-// Global return string for itoa function
-uint8_t itoa_str[8];
+/* Global return string for itoa function */
+char itoa_str[8];
 
-
-
-// *************************************************************************************************
-// @fn          lcd_init
-// @brief       Erase LCD memory. Init LCD peripheral.
-// @param      	none
-// @return      none
-// *************************************************************************************************
-void lcd_init(void)
-{
-	// Clear entire display memory
+void lcd_init(void) {
+	/* Clear entire display memory */
 	LCDBMEMCTL |= LCDCLRBM + LCDCLRM;
 
-	// LCD_FREQ = ACLK/16/8 = 256Hz 
-	// Frame frequency = 256Hz/4 = 64Hz, LCD mux 4, LCD on
+	/* LCD_FREQ = ACLK/16/8 = 256Hz  */
+	/* Frame frequency = 256Hz/4 = 64Hz, LCD mux 4, LCD on */
 	LCDBCTL0 = (LCDDIV0 + LCDDIV1 + LCDDIV2 + LCDDIV3) | (LCDPRE0 + LCDPRE1) | LCD4MUX | LCDON;
 
-	// LCB_BLK_FREQ = ACLK/8/4096 = 1Hz
+	/* LCB_BLK_FREQ = ACLK/8/4096 = 1Hz */
 	LCDBBLKCTL = LCDBLKPRE0 | LCDBLKPRE1 | LCDBLKDIV0 | LCDBLKDIV1 | LCDBLKDIV2 | LCDBLKMOD0; 
 
-	// I/O to COM outputs
+	/* I/O to COM outputs */
 	P5SEL |= (BIT5 | BIT6 | BIT7);
 	P5DIR |= (BIT5 | BIT6 | BIT7);
   
-	// Activate LCD output
-	LCDBPCTL0 = 0xFFFF;                         // Select LCD segments S0-S15
-	LCDBPCTL1 = 0x00FF;                         // Select LCD segments S16-S22
+	/* Activate LCD output */
+	LCDBPCTL0 = 0xFFFF;                         /* Select LCD segments S0-S15 */
+	LCDBPCTL1 = 0x00FF;                         /* Select LCD segments S16-S22 */
 
 #ifdef USE_LCD_CHARGE_PUMP
-	// Charge pump voltage generated internally, internal bias (V2-V4) generation
+	/* Charge pump voltage generated internally, internal bias (V2-V4) generation */
 	LCDBVCTL = LCDCPEN | VLCD_2_72;
 #endif
 }
 
-
-// *************************************************************************************************
-// @fn          clear_display_all
-// @brief       Erase LINE1 and LINE2 segments. Clear also function-specific content.
-// @param      	none
-// @return      none
-// *************************************************************************************************
-void clear_display_all(void)
-{
+void clear_display_all(void) {
 	// Clear generic content
 	clear_line(LINE1);
 	clear_line(LINE2);
-	
-	
 }
 
-
-// *************************************************************************************************
-// @fn          clear_display
-// @brief       Erase LINE1 and LINE2 segments. Keep icons.
-// @param      	none
-// @return      none
-// *************************************************************************************************
-void clear_display(void)
-{
+void clear_display(void) {
 	clear_line(LINE1);
 	clear_line(LINE2);
 }
 
-
-// *************************************************************************************************
-// @fn          clear_line
-// @brief       Erase segments of a given line.
-// @param      	uint8_t line	LINE1, LINE2
-// @return      none
-// *************************************************************************************************
-void clear_line(uint8_t line)
-{
+void clear_line(uint8_t line) {
 	display_chars(switch_seg(line, LCD_SEG_L1_3_0, LCD_SEG_L2_5_0), NULL, SEG_OFF);
-	if (line == LINE1)
-	{
+	if (line == LINE1) {
 		display_symbol(LCD_SEG_L1_DP1, SEG_OFF);
 		display_symbol(LCD_SEG_L1_DP0, SEG_OFF);
 		display_symbol(LCD_SEG_L1_COL, SEG_OFF);
 	}
-	else // line == LINE2
-	{
+    /* line == LINE2 */
+	else  {
 		display_symbol(LCD_SEG_L2_DP, SEG_OFF);
 		display_symbol(LCD_SEG_L2_COL1, SEG_OFF);
 		display_symbol(LCD_SEG_L2_COL0, SEG_OFF);
 	}
 }
 
-
-// *************************************************************************************************
-// @fn          write_segment
-// @brief       Write to one or multiple LCD segments
-// @param       lcdmem		Pointer to LCD byte memory
-//				bits		Segments to address
-//				bitmask		Bitmask for particular display item
-//				mode		On, off or blink segments
-// @return      
-// *************************************************************************************************
-void write_lcd_mem(uint8_t * lcdmem, uint8_t bits, uint8_t bitmask, uint8_t state)
-{
-	if (state == SEG_ON)
-	{
-		// Clear segments before writing
+void write_lcd_mem(uint8_t *lcdmem, uint8_t bits, uint8_t bitmask, uint8_t state) {
+	if (state == SEG_ON) {
+		/* Clear segments before writing */
 		*lcdmem = (uint8_t)(*lcdmem & ~bitmask);
 	
-		// Set visible segments
+		/* Set visible segments */
 		*lcdmem = (uint8_t)(*lcdmem | bits);
 	}
-	else if (state == SEG_OFF)
-	{
-		// Clear segments
+	else if (state == SEG_OFF) {
+		/* Clear segments */
 		*lcdmem = (uint8_t)(*lcdmem & ~bitmask);
 	}
-	else if (state == SEG_ON_BLINK_ON)
-	{
-		// Clear visible / blink segments before writing
+	else if (state == SEG_ON_BLINK_ON) {
+		/* Clear visible / blink segments before writing */
 		*lcdmem 		= (uint8_t)(*lcdmem & ~bitmask);
 		*(lcdmem+0x20) 	= (uint8_t)(*(lcdmem+0x20) & ~bitmask);
 	
-		// Set visible / blink segments
+		/* Set visible / blink segments */
 		*lcdmem 		= (uint8_t)(*lcdmem | bits);
 		*(lcdmem+0x20) 	= (uint8_t)(*(lcdmem+0x20) | bits);
 	}
-	else if (state == SEG_ON_BLINK_OFF)
-	{
-		// Clear visible segments before writing
+	else if (state == SEG_ON_BLINK_OFF) {
+		/* Clear visible segments before writing */
 		*lcdmem = (uint8_t)(*lcdmem & ~bitmask);
 	
-		// Set visible segments
+		/* Set visible segments */
 		*lcdmem = (uint8_t)(*lcdmem | bits);
 
-		// Clear blink segments
+		/* Clear blink segments */
 		*(lcdmem+0x20) 	= (uint8_t)(*(lcdmem+0x20) & ~bitmask);
 	}
-	else if (state == SEG_OFF_BLINK_OFF)
-	{
-		// Clear segments
+	else if (state == SEG_OFF_BLINK_OFF) {
+		/* Clear segments */
 		*lcdmem = (uint8_t)(*lcdmem & ~bitmask);
 
-		// Clear blink segments
+		/* Clear blink segments */
 		*(lcdmem+0x20) 	= (uint8_t)(*(lcdmem+0x20) & ~bitmask);
 	}
 }
 
-
-// *************************************************************************************************
-// @fn          itoa
-// @brief       Generic integer to array routine. Converts integer n to string.
-//				Default conversion result has leading zeros, e.g. "00123"
-//				Option to convert leading '0' into whitespace (blanks)
-// @param       uint32_t n			integer to convert
-//				uint8_t digits		number of digits
-//				uint8_t blanks		fill up result string with number of whitespaces instead of leading zeros  
-// @return      uint8_t				string
-// *************************************************************************************************
-uint8_t * itoa(uint32_t n, uint8_t digits, uint8_t blanks)
-{
+char *itoa(uint32_t n, uint8_t digits, uint8_t blanks) {
 	uint8_t i;
 	uint8_t digits1 = digits;
 	
-	// Preset result string
+	/* Preset result string */
 	memcpy(itoa_str, "0000000", 7);
 
-	// Return empty string if number of digits is invalid (valid range for digits: 1-7)
-	if ((digits == 0) || (digits > 7)) return (itoa_str);
+	/* Return empty string if number of digits is invalid (valid range for digits: 1-7) */
+	if ((digits == 0) || (digits > 7))  {
+        return (itoa_str);
+    }
 	
-	// Numbers 0 .. 180 can be copied from itoa_conversion_table without conversion
-	if (n <= 180)
-	{
-		if (digits >= 3)
-		{
+	/* Numbers 0 .. 180 can be copied from itoa_conversion_table without conversion */
+	if (n <= 180) {
+		if (digits >= 3) {
 			memcpy(itoa_str+(digits-3), itoa_conversion_table[n], 3);
 		}
-		else // digits == 1 || 2  
-		{
+        /* digits == 1 || 2   */
+        else {
 			memcpy(itoa_str, itoa_conversion_table[n]+(3-digits), digits);
 		}
 	}
-	else // For n > 180 need to calculate string content
-	{
-		// Calculate digits from least to most significant number
-		do 								
-		{     
+    /* For n > 180 need to calculate string content */
+	else {
+		/* Calculate digits from least to most significant number */
+		do {     
 			itoa_str[digits-1] = n % 10 + '0';   	
 			n /= 10;
 		} while (--digits > 0);  		
 	}
 
-	// Remove specified number of leading '0', always keep last one
+	/* Remove specified number of leading '0', always keep last one */
 	i = 0;	
-	while ((itoa_str[i] == '0') && (i < digits1-1))	
-	{
-		if (blanks > 0)
-		{
-			// Convert only specified number of leading '0'
+	while ((itoa_str[i] == '0') && (i < digits1-1))	{
+		if (blanks > 0) {
+			/* Convert only specified number of leading '0' */
 			itoa_str[i]=' ';
 			blanks--;
 		}
 		i++;
 	}
-	
 	return (itoa_str);	
 } 
 
-
-// *************************************************************************************************
-// @fn          display_value1
-// @brief       Generic decimal display routine. Used exclusively by set_value function.
-// @param       uint8_t segments		LCD segments where value is displayed
-//				uint32_t value			Integer value to be displayed
-//				uint8_t digits			Number of digits to convert
-//				uint8_t blanks			Number of leadings blanks in itoa result string
-// @return      none
-// *************************************************************************************************
-void display_value1(uint8_t segments, uint32_t value, uint8_t digits, uint8_t blanks, uint8_t disp_mode)
-{
-	uint8_t* str;
+void display_value1(uint8_t segments, uint32_t value, uint8_t digits, uint8_t blanks, uint8_t disp_mode) {
+	char *str;
 
 	str = itoa(value, digits, blanks);
 
-	// Display string in blink mode
-	display_chars(segments, (char*) str, disp_mode);
+	/* Display string in blink mode */
+	display_chars(segments, str, disp_mode);
 }
 
-
-// *************************************************************************************************
-// @fn          display_symbol
-// @brief       Switch symbol on or off on LCD.
-// @param       uint8_t symbol		A valid LCD symbol (index 0..42)
-//				uint8_t state		SEG_ON, SEG_OFF, SEG_BLINK
-// @return      none
-// *************************************************************************************************
-void display_symbol(uint8_t symbol, uint8_t mode)
-{
-	uint8_t * lcdmem;
+void display_symbol(uint8_t symbol, uint8_t mode) {
+	uint8_t *lcdmem;
 	uint8_t bits;
 	uint8_t bitmask;
 	
-	if (symbol <= LCD_SEG_L2_DP) 
-	{
-		// Get LCD memory address for symbol from table
-		lcdmem 	= (uint8_t *)segments_lcdmem[symbol];
+	if (symbol <= LCD_SEG_L2_DP) {
+		/* Get LCD memory address for symbol from table */
+		lcdmem 	= (uint8_t*)segments_lcdmem[symbol];
 	
-		// Get bits for symbol from table
+		/* Get bits for symbol from table */
 		bits 	= segments_bitmask[symbol];
 		
-		// Bitmask for symbols equals bits
+		/* Bitmask for symbols equals bits */
 		bitmask = bits;
 	
-		// Write LCD memory 	
+		/* Write LCD memory 	 */
 		write_lcd_mem(lcdmem, bits, bitmask, mode);
 	}
 }
 
-
-// *************************************************************************************************
-// @fn          display_char
-// @brief       Write to 7-segment characters.
-// @param       uint8_t segment		A valid LCD segment 
-//				uint8_t chr			Character to display
-//				uint8_t mode		SEG_ON, SEG_OFF, SEG_BLINK
-// @return      none
-// *************************************************************************************************
-void display_char(uint8_t segment, char chr, uint8_t mode)
-{
-	uint8_t * lcdmem;			// Pointer to LCD memory
-	uint8_t bitmask;			// Bitmask for character
-	uint8_t bits, bits1;		// Bits to write
+void display_char(uint8_t segment, char chr, uint8_t mode) {
+	uint8_t *lcdmem;			/* Pointer to LCD memory */
+	uint8_t bitmask;			/* Bitmask for character */
+	uint8_t bits, bits1;		/* Bits to write */
 	
-	// Write to single 7-segment character
-	if ((segment >= LCD_SEG_L1_3) && (segment <= LCD_SEG_L2_DP))
-	{
-		// Get LCD memory address for segment from table
-		lcdmem = (uint8_t *)segments_lcdmem[segment];
+	/* Write to single 7-segment character */
+	if ((segment >= LCD_SEG_L1_3) && (segment <= LCD_SEG_L2_DP)) {
+		/* Get LCD memory address for segment from table */
+		lcdmem = (uint8_t*)segments_lcdmem[segment];
 
-		// Get bitmask for character from table
+		/* Get bitmask for character from table */
 		bitmask = segments_bitmask[segment];
 		
-		// Get bits from font set
-		if ((chr >= 0x30) && (chr <= 0x5A)) 
-		{
-			// Use font set
+		/* Get bits from font set */
+		if ((chr >= 0x30) && (chr <= 0x5A)) {
+			/* Use font set */
 			bits = lcd_font[chr-0x30];
 		}
-		else if (chr == 0x2D)
-		{
-			// '-' not in font set
+		else if (chr == 0x2D) {
+			/* '-' not in font set */
 			bits = BIT1;
 		}
-		else
-		{
-			// Other characters map to ' ' (blank)
+		else {
+			/* Other characters map to ' ' (blank) */
 			bits = 0;
 		}
 
-		// When addressing LINE2 7-segment characters need to swap high- and low-nibble,
-		// because LCD COM/SEG assignment is mirrored against LINE1
-		if (segment >= LCD_SEG_L2_5) 
-		{
+		/* When addressing LINE2 7-segment characters need to swap high- and low-nibble, */
+		/* because LCD COM/SEG assignment is mirrored against LINE1 */
+		if (segment >= LCD_SEG_L2_5) {
 			bits1 = ((bits << 4) & 0xF0) | ((bits >> 4) & 0x0F);
 			bits = bits1;
 
-			// When addressing LCD_SEG_L2_5, need to convert ASCII '1' and 'L' to 1 bit,
-			// because LCD COM/SEG assignment is special for this incomplete character
-			if (segment == LCD_SEG_L2_5) 
-			{
+			/* When addressing LCD_SEG_L2_5, need to convert ASCII '1' and 'L' to 1 bit, */
+			/* because LCD COM/SEG assignment is special for this incomplete character */
+			if (segment == LCD_SEG_L2_5) {
 				if ((chr == '1') || (chr == 'L')) bits = BIT7;
 			}
 		}
 		
-		// Physically write to LCD memory		
+		/* Physically write to LCD memory		 */
 		write_lcd_mem(lcdmem, bits, bitmask, mode);
 	}
 }	
-	
 
-// *************************************************************************************************
-// @fn          display_chars
-// @brief       Write to consecutive 7-segment characters.
-// @param       uint8_t segments	LCD segment array 
-//				uint8_t * str		Pointer to a string
-//				uint8_t mode		SEG_ON, SEG_OFF, SEG_BLINK
-// @return      none
-// *************************************************************************************************
 void display_chars(uint8_t segments, char *str, uint8_t mode) {
 	uint8_t i;
-	uint8_t length = 0;			// Write length
-	uint8_t char_start = 0;			// Starting point for consecutive write
+	uint8_t length = 0;			/* Write length */
+	uint8_t char_start = 0;			/* Starting point for consecutive write */
 	
-	switch (segments)
-	{
-		// LINE1
-		case LCD_SEG_L1_3_0:	length=4; char_start=LCD_SEG_L1_3; break;
-		case LCD_SEG_L1_2_0:	length=3; char_start=LCD_SEG_L1_2; break;
-		case LCD_SEG_L1_1_0: 	length=2; char_start=LCD_SEG_L1_1; break;
-		case LCD_SEG_L1_3_1: 	length=3; char_start=LCD_SEG_L1_3; break;
-		case LCD_SEG_L1_3_2: 	length=2; char_start=LCD_SEG_L1_3; break;
-
-		// LINE2
-		case LCD_SEG_L2_5_0:	length=6; char_start=LCD_SEG_L2_5; break;
-		case LCD_SEG_L2_4_0:	length=5; char_start=LCD_SEG_L2_4; break;
-		case LCD_SEG_L2_3_0:	length=4; char_start=LCD_SEG_L2_3; break;
-		case LCD_SEG_L2_2_0:	length=3; char_start=LCD_SEG_L2_2; break;
-		case LCD_SEG_L2_1_0: 	length=2; char_start=LCD_SEG_L2_1; break;
-		case LCD_SEG_L2_5_4:	length=2; char_start=LCD_SEG_L2_5; break;
-		case LCD_SEG_L2_5_2:	length=4; char_start=LCD_SEG_L2_5; break;
-		case LCD_SEG_L2_3_2:	length=2; char_start=LCD_SEG_L2_3; break;
-		case LCD_SEG_L2_4_2: 	length=3; char_start=LCD_SEG_L2_4; break;
+	switch (segments) {
+		/* LINE1 */
+		case LCD_SEG_L1_3_0:	
+            length=4; 
+            char_start=LCD_SEG_L1_3; 
+            break;
+		case LCD_SEG_L1_2_0:	
+            length=3; 
+            char_start=LCD_SEG_L1_2; 
+            break;
+		case LCD_SEG_L1_1_0: 	
+            length=2; 
+            char_start=LCD_SEG_L1_1; 
+            break;
+		case LCD_SEG_L1_3_1: 	
+            length=3; 
+            char_start=LCD_SEG_L1_3; 
+            break;
+		case LCD_SEG_L1_3_2: 	
+            length=2; 
+            char_start=LCD_SEG_L1_3; 
+            break;
+
+		/* LINE2 */
+		case LCD_SEG_L2_5_0:	
+            length=6; 
+            char_start=LCD_SEG_L2_5; 
+            break;
+		case LCD_SEG_L2_4_0:	
+            length=5; 
+            char_start=LCD_SEG_L2_4; 
+            break;
+		case LCD_SEG_L2_3_0:	
+            length=4; 
+            char_start=LCD_SEG_L2_3; 
+            break;
+		case LCD_SEG_L2_2_0:	
+            length=3; 
+            char_start=LCD_SEG_L2_2; 
+            break;
+		case LCD_SEG_L2_1_0: 	
+            length=2; 
+            char_start=LCD_SEG_L2_1; 
+            break;
+		case LCD_SEG_L2_5_4:	
+            length=2; 
+            char_start=LCD_SEG_L2_5; 
+            break;
+		case LCD_SEG_L2_5_2:	
+            length=4; 
+            char_start=LCD_SEG_L2_5; 
+            break;
+		case LCD_SEG_L2_3_2:	
+            length=2; 
+            char_start=LCD_SEG_L2_3; 
+            break;
+		case LCD_SEG_L2_4_2: 	
+            length=3; 
+            char_start=LCD_SEG_L2_4; 
+            break;
 	}
 	
-	// Write to consecutive digits
-	for(i=0; i<length; i++)
-	{
-		// Use single character routine to write display memory
+	/* Write to consecutive digits */
+	for(i=0; i<length; i++) {
+		/* Use single character routine to write display memory */
 		display_char(char_start+i, *(str+i), mode);
 	}
 }
 
-
-// *************************************************************************************************
-// @fn          switch_seg
-// @brief       Returns index of 7-segment character. Required for display routines that can draw 
-//				information on both lines.
-// @param       uint8_t line		LINE1, LINE2
-//				uint8_t index1		Index of LINE1
-//				uint8_t index2		Index of LINE2
-// @return      uint8
-// *************************************************************************************************
-uint8_t switch_seg(uint8_t line, uint8_t index1, uint8_t index2)
-{
-	if (line == LINE1)
-	{
+uint8_t switch_seg(uint8_t line, uint8_t index1, uint8_t index2) {
+	if (line == LINE1) {
 		return index1;
 	}
-	else // line == LINE2
-	{
+    /* line == LINE2 */
+	else {
 		return index2;
 	}
 }
 
-
-// *************************************************************************************************
-// @fn          start_blink
-// @brief       Start blinking. 
-// @param       none
-// @return      none
-// *************************************************************************************************
-void start_blink(void)
-{
+void start_blink(void) {
 	LCDBBLKCTL |= LCDBLKMOD0;
 }
 
-
-// *************************************************************************************************
-// @fn          stop_blink
-// @brief       Stop blinking.
-// @param       none
-// @return      none
-// *************************************************************************************************
-void stop_blink(void)
-{
+void stop_blink(void) {
 	LCDBBLKCTL &= ~LCDBLKMOD0;
 }
 
-
-// *************************************************************************************************
-// @fn          stop_blink
-// @brief       Clear blinking memory.
-// @param       none
-// @return      none
-// *************************************************************************************************
-void clear_blink_mem(void)
-{
+void clear_blink_mem(void) {
 	LCDBMEMCTL |= LCDCLRBM;	
 }
 
-
-// *************************************************************************************************
-// @fn          set_blink_rate
-// @brief       Set blink rate register bits. 
-// @param       none
-// @return      none
-// *************************************************************************************************
-void set_blink_rate(uint8_t bits)
-{
+void set_blink_rate(uint8_t bits) {
 	LCDBBLKCTL &= ~(BIT7 | BIT6 | BIT5);	
 	LCDBBLKCTL |= bits;	
 }
 
-
-// *************************************************************************************************
-// @fn          display_all_off
-// @brief       Sets everything of on the display
-// @param       none
-// @return      none
-// *************************************************************************************************
-void display_all_off(void)
-{
-	uint8_t * lcdptr = (uint8_t*)0x0A20;
+void display_all_off(void) {
+	uint8_t *lcdptr = (uint8_t*)0x0A20;
 	uint8_t i;
 	
-	for (i=1; i<=12; i++) 
-	{
+	for (i=1; i<=12; i++) {
 		*lcdptr = 0x00; 
 		lcdptr++;
 	}
diff --git a/chronos/drivers/display.h b/chronos/drivers/display.h
index a4fbde92b185..805d801d2e18 100644
--- a/chronos/drivers/display.h
+++ b/chronos/drivers/display.h
@@ -1,72 +1,55 @@
-// *************************************************************************************************
-//
-//	Copyright (C) 2009 Texas Instruments Incorporated - http://www.ti.com/ 
-//	 
-//	 
-//	  Redistribution and use in source and binary forms, with or without 
-//	  modification, are permitted provided that the following conditions 
-//	  are met:
-//	
-//	    Redistributions of source code must retain the above copyright 
-//	    notice, this list of conditions and the following disclaimer.
-//	 
-//	    Redistributions in binary form must reproduce the above copyright
-//	    notice, this list of conditions and the following disclaimer in the 
-//	    documentation and/or other materials provided with the   
-//	    distribution.
-//	 
-//	    Neither the name of Texas Instruments Incorporated nor the names of
-//	    its contributors may be used to endorse or promote products derived
-//	    from this software without specific prior written permission.
-//	
-//	  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
-//	  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
-//	  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-//	  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
-//	  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
-//	  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
-//	  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-//	  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-//	  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
-//	  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
-//	  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// *************************************************************************************************
+/* *************************************************************************************************
+ *
+ *	Copyright (C) 2009 Texas Instruments Incorporated - http://www.ti.com/ 
+ *	 
+ *	 
+ *	  Redistribution and use in source and binary forms, with or without 
+ *	  modification, are permitted provided that the following conditions 
+ *	  are met:
+ *	
+ *	    Redistributions of source code must retain the above copyright 
+ *	    notice, this list of conditions and the following disclaimer.
+ *	 
+ *	    Redistributions in binary form must reproduce the above copyright
+ *	    notice, this list of conditions and the following disclaimer in the 
+ *	    documentation and/or other materials provided with the   
+ *	    distribution.
+ *	 
+ *	    Neither the name of Texas Instruments Incorporated nor the names of
+ *	    its contributors may be used to endorse or promote products derived
+ *	    from this software without specific prior written permission.
+ *	
+ *	  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ *	  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ *	  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *	  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+ *	  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ *	  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ *	  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *	  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *	  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ *	  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ *	  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * *************************************************************************************************
+ * Basic display functions.
+ * ************************************************************************************************/
 
 #ifndef __DISPLAY_H
 #define __DISPLAY_H
 
-
-// *************************************************************************************************
-// Include section
-
-/*
- * Set some options at compile time for how the time is displayed
- * The options are, in order of code space used-
- * OPTION_TIME_DISPLAY == CLOCK_24HR
- * OPTION_TIME_DISPLAY == CLOCK_AM_PM
- * OPTION_TIME_DISPLAY == CLOCK_DISPLAY_SELECT
- */
-
-#define CLOCK_24HR              0
-#define CLOCK_AM_PM             1
-#define CLOCK_DISPLAY_SELECT    2
-
+#define CLOCK_24HR              (0)
+#define CLOCK_AM_PM             (1)
+#define CLOCK_DISPLAY_SELECT    (2)
 
 
+/* *************************************************************************************************
+ * Global Variable section */
 
-// *************************************************************************************************
-// Extern section
-
-// *************************************************************************************************
-// Global Variable section
-
-// Set of display flags
-typedef union
-{
-  struct
-  {
-  	// Line1 + Line2 + Icons
+/* Set of display flags */
+typedef union {
+  struct {
+  	/* Line1 + Line2 + Icons*/
     uint16_t full_update      		: 1;    // 1 = Redraw all content
     uint16_t partial_update      	: 1;    // 1 = Update changes
   	
@@ -90,7 +73,7 @@ extern volatile s_display_flags display;
 
 // Constants defined in library
 extern const uint8_t lcd_font[];
-extern const uint8_t * segments_lcdmem[];
+extern const uint8_t *segments_lcdmem[];
 extern const uint8_t segments_bitmask[];
 extern const uint8_t itoa_conversion_table[][3];
 
@@ -127,30 +110,31 @@ extern const uint8_t itoa_conversion_table[][3];
 #define SEG_F                	(BIT0)
 #define SEG_G                	(BIT1)
 
-// ------------------------------------------
-// LCD symbols for easier access
-//
-// xxx_SEG_xxx 		= Seven-segment character (sequence 5-4-3-2-1-0)
-// xxx_SYMB_xxx 	= Display symbol, e.g. "AM" for ante meridiem 
-// xxx_UNIT_xxx 	= Display unit, e.g. "km/h" for kilometers per hour
-// xxx_ICON_xxx 	= Display icon, e.g. heart to indicate reception of heart rate data
-// xxx_L1_xxx 		= Item is part of Line1 information 
-// xxx_L2_xxx 		= Item is part of Line2 information
-
-// Symbols for Line1
+/* ------------------------------------------
+ * LCD symbols for easier access
+ *
+ * xxx_SEG_xxx 		= Seven-segment character (sequence 5-4-3-2-1-0)
+ * xxx_SYMB_xxx 	= Display symbol, e.g. "AM" for ante meridiem 
+ * xxx_UNIT_xxx 	= Display unit, e.g. "km/h" for kilometers per hour
+ * xxx_ICON_xxx 	= Display icon, e.g. heart to indicate reception of heart rate data
+ * xxx_L1_xxx 		= Item is part of Line1 information 
+ * xxx_L2_xxx 		= Item is part of Line2 information
+ */
+
+//* Symbols for Line1 */
 #define LCD_SYMB_AM					0
 #define LCD_SYMB_PM					1
 #define LCD_SYMB_ARROW_UP			2
 #define LCD_SYMB_ARROW_DOWN			3
 #define LCD_SYMB_PERCENT			4
 
-// Symbols for Line2
+/* Symbols for Line2 */
 #define LCD_SYMB_TOTAL				5
 #define LCD_SYMB_AVERAGE			6
 #define LCD_SYMB_MAX				7
 #define LCD_SYMB_BATTERY			8
 
-// Units for Line1
+/* Units for Line1 */
 #define LCD_UNIT_L1_FT				9
 #define LCD_UNIT_L1_K				10
 #define LCD_UNIT_L1_M				11
@@ -159,12 +143,12 @@ extern const uint8_t itoa_conversion_table[][3];
 #define LCD_UNIT_L1_PER_H			14
 #define LCD_UNIT_L1_DEGREE			15
 
-// Units for Line2
+/* Units for Line2 */
 #define LCD_UNIT_L2_KCAL			16
 #define LCD_UNIT_L2_KM				17
 #define LCD_UNIT_L2_MI				18
 
-// Icons
+/* Icons */
 #define LCD_ICON_HEART				19
 #define LCD_ICON_STOPWATCH			20
 #define LCD_ICON_RECORD				21
@@ -173,7 +157,7 @@ extern const uint8_t itoa_conversion_table[][3];
 #define LCD_ICON_BEEPER2			24
 #define LCD_ICON_BEEPER3			25
 
-// Line1 7-segments
+/* Line1 7-segments */
 #define LCD_SEG_L1_3				26
 #define LCD_SEG_L1_2				27
 #define LCD_SEG_L1_1				28
@@ -182,7 +166,7 @@ extern const uint8_t itoa_conversion_table[][3];
 #define LCD_SEG_L1_DP1				31
 #define LCD_SEG_L1_DP0				32
 
-// Line2 7-segments
+/* Line2 7-segments */
 #define LCD_SEG_L2_5				33
 #define LCD_SEG_L2_4				34
 #define LCD_SEG_L2_3				35
@@ -193,15 +177,14 @@ extern const uint8_t itoa_conversion_table[][3];
 #define LCD_SEG_L2_COL0				40
 #define LCD_SEG_L2_DP				41
 
-
-// Line1 7-segment arrays
+/* Line1 7-segment arrays */
 #define LCD_SEG_L1_3_0				70
 #define LCD_SEG_L1_2_0				71
 #define LCD_SEG_L1_1_0				72
 #define LCD_SEG_L1_3_1				73
 #define LCD_SEG_L1_3_2				74
 
-// Line2 7-segment arrays
+/* Line2 7-segment arrays */
 #define LCD_SEG_L2_5_0				90
 #define LCD_SEG_L2_4_0				91
 #define LCD_SEG_L2_3_0				92
@@ -212,8 +195,7 @@ extern const uint8_t itoa_conversion_table[][3];
 #define LCD_SEG_L2_5_4				97
 #define LCD_SEG_L2_4_2				98
 
-
-// LCD controller memory map
+/* LCD controller memory map */
 #define LCD_MEM_1          			((uint8_t*)0x0A20)
 #define LCD_MEM_2          			((uint8_t*)0x0A21)
 #define LCD_MEM_3          			((uint8_t*)0x0A22)
@@ -227,8 +209,7 @@ extern const uint8_t itoa_conversion_table[][3];
 #define LCD_MEM_11         			((uint8_t*)0x0A2A)
 #define LCD_MEM_12         			((uint8_t*)0x0A2B)
 
-
-// Memory assignment
+/* Memory assignment */
 #define LCD_SEG_L1_0_MEM			(LCD_MEM_6)
 #define LCD_SEG_L1_1_MEM			(LCD_MEM_4)
 #define LCD_SEG_L1_2_MEM			(LCD_MEM_3)
@@ -272,7 +253,7 @@ extern const uint8_t itoa_conversion_table[][3];
 #define LCD_ICON_BEEPER2_MEM		(LCD_MEM_6)
 #define LCD_ICON_BEEPER3_MEM		(LCD_MEM_7)
 
-// Bit masks for write access
+/* Bit masks for write access */
 #define LCD_SEG_L1_0_MASK			(BIT2+BIT1+BIT0+BIT7+BIT6+BIT5+BIT4)
 #define LCD_SEG_L1_1_MASK			(BIT2+BIT1+BIT0+BIT7+BIT6+BIT5+BIT4)
 #define LCD_SEG_L1_2_MASK			(BIT2+BIT1+BIT0+BIT7+BIT6+BIT5+BIT4)
@@ -317,44 +298,161 @@ extern const uint8_t itoa_conversion_table[][3];
 #define LCD_ICON_BEEPER3_MASK		(BIT3)
 
 
+/* *************************************************************************************************
+ * API section
+ */
 
-// *************************************************************************************************
-// API section
-
-// Physical LCD memory write
-void write_lcd_mem(uint8_t * lcdmem, uint8_t bits, uint8_t bitmask, uint8_t state);
-
-// Display init / clear
+/* Physical LCD memory write */
+/* *************************************************************************************************
+ * @fn          write_segment
+ * @brief       Write to one or multiple LCD segments
+ * @param       lcdmem		Pointer to LCD byte memory
+ *				bits		Segments to address
+ *				bitmask		Bitmask for particular display item
+ *				mode		On, off or blink segments
+ * @return      
+ * ************************************************************************************************/
+void write_lcd_mem(uint8_t *lcdmem, uint8_t bits, uint8_t bitmask, uint8_t state);
+
+/* Display init / clear */
+/* *************************************************************************************************
+ * @fn          lcd_init
+ * @brief       Erase LCD memory. Init LCD peripheral.
+ * @param      	none
+ * @return      none
+ * ************************************************************************************************/
 void lcd_init(void);
+
+/* *************************************************************************************************
+ * @fn          clear_display
+ * @brief       Erase LINE1 and LINE2 segments. Keep icons.
+ * @param      	none
+ * @return      none
+ * ************************************************************************************************/
 void clear_display(void);
+
+/* *************************************************************************************************
+ * @fn          clear_display_all
+ * @brief       Erase LINE1 and LINE2 segments. Clear also function-specific content.
+ * @param      	none
+ * @return      none
+ * ************************************************************************************************/
 void clear_display_all(void);
+
+/* *************************************************************************************************
+ * @fn          clear_line
+ * @brief       Erase segments of a given line.
+ * @param      	uint8_t line	LINE1, LINE2
+ * @return      none
+ * ************************************************************************************************/
 void clear_line(uint8_t line);
 
-// Blinking function
+/* Blinking function */
+/* *************************************************************************************************
+ * @fn          start_blink
+ * @brief       Start blinking. 
+ * @param       none
+ * @return      none
+ * ************************************************************************************************/
 void start_blink(void);
+
+/* *************************************************************************************************
+ * @fn          stop_blink
+ * @brief       Stop blinking.
+ * @param       none
+ * @return      none
+ * ************************************************************************************************/
 void stop_blink(void);
+
+/* *************************************************************************************************
+ * @fn          stop_blink
+ * @brief       Clear blinking memory.
+ * @param       none
+ * @return      none
+ * ************************************************************************************************/
 void clear_blink_mem(void);
+
+/* *************************************************************************************************
+ * @fn          set_blink_rate
+ * @brief       Set blink rate register bits. 
+ * @param       none
+ * @return      none
+ * ************************************************************************************************/
 void set_blink_rate(uint8_t bits);
 
-// Character / symbol draw functions
+/* Character / symbol draw functions */
+/* *************************************************************************************************
+ * @fn          display_char
+ * @brief       Write to 7-segment characters.
+ * @param       uint8_t segment		A valid LCD segment 
+ *				uint8_t chr			Character to display
+ *				uint8_t mode		SEG_ON, SEG_OFF, SEG_BLINK
+ * @return      none
+ * ************************************************************************************************/
 void display_char(uint8_t segment, char chr, uint8_t mode);
-void display_chars(uint8_t segments, char* str, uint8_t mode);
-void display_symbol(uint8_t symbol, uint8_t mode);
 
-// Time display function
-void DisplayTime(uint8_t updateMode);
-void display_am_pm_symbol(uint8_t timeAM);
+/* *************************************************************************************************
+ * @FN          display_chars
+ * @brief       Write to consecutive 7-segment characters.
+ * @param       uint8_t segments	LCD segment array 
+ *				uint8_t * str		Pointer to a string
+ *				uint8_t mode		SEG_ON, SEG_OFF, SEG_BLINK
+ * @return      none
+ * ************************************************************************************************/
+void display_chars(uint8_t segments, char *str, uint8_t mode);
+
+/* *************************************************************************************************
+ * @fn          display_symbol
+ * @brief       Switch symbol on or off on LCD.
+ * @param       uint8_t symbol		A valid LCD symbol (index 0..42)
+ *				uint8_t state		SEG_ON, SEG_OFF, SEG_BLINK
+ * @return      none
+ * ************************************************************************************************/
+void display_symbol(uint8_t symbol, uint8_t mode);
 
-// Set_value display functions
+/* Set_value display functions */
+/* *************************************************************************************************
+ * @fn          display_value1
+ * @brief       Generic decimal display routine. Used exclusively by set_value function.
+ * @param       uint8_t segments		LCD segments where value is displayed
+ *				uint32_t value			Integer value to be displayed
+ *				uint8_t digits			Number of digits to convert
+ *				uint8_t blanks			Number of leadings blanks in itoa result string
+ * @return      none
+ * ************************************************************************************************/
 void display_value1(uint8_t segments, uint32_t value, uint8_t digits, uint8_t blanks, uint8_t disp_mode);
-void display_hours_12_or_24(uint8_t segments, uint32_t value, uint8_t digits, uint8_t blanks, uint8_t disp_mode);
-
-// Integer to string conversion 
-uint8_t * itoa(uint32_t n, uint8_t digits, uint8_t blanks);
 
-// Segment index helper function
+/* Integer to string conversion  */
+/* *************************************************************************************************
+ * @fn          itoa
+ * @brief       Generic integer to array routine. Converts integer n to string.
+ *				Default conversion result has leading zeros, e.g. "00123"
+ *				Option to convert leading '0' into whitespace (blanks)
+ * @param       uint32_t n			integer to convert
+ *				uint8_t digits		number of digits
+ *				uint8_t blanks		fill up result string with number of whitespaces instead of leading zeros  
+ * @return      uint8_t				string
+ * ************************************************************************************************/
+char *itoa(uint32_t n, uint8_t digits, uint8_t blanks);
+
+/* Segment index helper function */
+/* *************************************************************************************************
+ * @fn          switch_seg
+ * @brief       Returns index of 7-segment character. Required for display routines that can draw 
+ *				information on both lines.
+ * @param       uint8_t line		LINE1, LINE2
+ *				uint8_t index1		Index of LINE1
+ *				uint8_t index2		Index of LINE2
+ * @return      uint8
+ * ************************************************************************************************/
 uint8_t switch_seg(uint8_t line, uint8_t index1, uint8_t index2);
 
+/* *************************************************************************************************
+ * @fn          display_all_off
+ * @brief       Sets everything of on the display
+ * @param       none
+ * @return      none
+ * ************************************************************************************************/
 void display_all_off(void);
 
-#endif // __DISPLAY_
+#endif /* __DISPLAY_ */
diff --git a/chronos/drivers/display1.c b/chronos/drivers/display1.c
index 6a14fd3bd02c..40795d54bbde 100644
--- a/chronos/drivers/display1.c
+++ b/chronos/drivers/display1.c
@@ -1,119 +1,103 @@
-// *************************************************************************************************
-//
-//	Copyright (C) 2009 Texas Instruments Incorporated - http://www.ti.com/ 
-//	 
-//	 
-//	  Redistribution and use in source and binary forms, with or without 
-//	  modification, are permitted provided that the following conditions 
-//	  are met:
-//	
-//	    Redistributions of source code must retain the above copyright 
-//	    notice, this list of conditions and the following disclaimer.
-//	 
-//	    Redistributions in binary form must reproduce the above copyright
-//	    notice, this list of conditions and the following disclaimer in the 
-//	    documentation and/or other materials provided with the   
-//	    distribution.
-//	 
-//	    Neither the name of Texas Instruments Incorporated nor the names of
-//	    its contributors may be used to endorse or promote products derived
-//	    from this software without specific prior written permission.
-//	
-//	  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
-//	  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
-//	  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-//	  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
-//	  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
-//	  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
-//	  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-//	  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-//	  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
-//	  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
-//	  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-// *************************************************************************************************
-// Basic display functions.
-// *************************************************************************************************
-
-
-// *************************************************************************************************
-// Include section
-#include  "cc430x613x.h"
-
-
-// driver
-#include "display.h"
-
-
-// *************************************************************************************************
-// Prototypes section
-
-
-// *************************************************************************************************
-// Defines section
-
-
-
-// *************************************************************************************************
-// Global Variable section
-
-// Table with memory bit assignment for digits "0" to "9" and characters "A" to "Z"
-//   A
-// F   B
-//   G
-// E   C
-//   D
-const uint8_t lcd_font[] =
-{
-  SEG_A+SEG_B+SEG_C+SEG_D+SEG_E+SEG_F,           // Displays "0"
-        SEG_B+SEG_C,                             // Displays "1"
-  SEG_A+SEG_B+      SEG_D+SEG_E+      SEG_G,     // Displays "2"
-  SEG_A+SEG_B+SEG_C+SEG_D+            SEG_G,     // Displays "3"
-        SEG_B+SEG_C+            SEG_F+SEG_G,     // Displays "4"
-  SEG_A+      SEG_C+SEG_D+      SEG_F+SEG_G,     // Displays "5"
-  SEG_A+      SEG_C+SEG_D+SEG_E+SEG_F+SEG_G,     // Displays "6"
-  SEG_A+SEG_B+SEG_C,                             // Displays "7"
-  SEG_A+SEG_B+SEG_C+SEG_D+SEG_E+SEG_F+SEG_G,     // Displays "8"
-  SEG_A+SEG_B+SEG_C+SEG_D+      SEG_F+SEG_G,     // Displays "9"
-  0                                        ,     // Displays " " (:)
-  0                                        ,     // Displays " " (;)
-  SEG_A+                        SEG_F+SEG_G,     // Displays "<" as high c
-                    SEG_D+            SEG_G,     // Displays "="
-  0                                        ,     // Displays " " (>)
-  SEG_A+SEG_B+            SEG_E+      SEG_G,     // Displays "?"
-  0                                        ,     // Displays " " (@)
-  SEG_A+SEG_B+SEG_C+      SEG_E+SEG_F+SEG_G,     // Displays "A"
-              SEG_C+SEG_D+SEG_E+SEG_F+SEG_G,     // Displays "b"
-                    SEG_D+SEG_E+      SEG_G,     // Displays "c"
-        SEG_B+SEG_C+SEG_D+SEG_E+      SEG_G,     // Displays "d"
-  SEG_A+           +SEG_D+SEG_E+SEG_F+SEG_G,     // Displays "E"
-  SEG_A+                  SEG_E+SEG_F+SEG_G,     // Displays "f"
-  SEG_A+SEG_B+SEG_C+SEG_D+      SEG_F+SEG_G,     // Displays "g" same as 9
-              SEG_C+      SEG_E+SEG_F+SEG_G,     // Displays "h"
-                          SEG_E            ,     // Displays "i"
-  SEG_A+SEG_B+SEG_C+SEG_D                  ,     // Displays "J"
-  		     		SEG_D+      SEG_F+SEG_G,     // Displays "k"
-                    SEG_D+SEG_E+SEG_F      ,     // Displays "L"
-  SEG_A+SEG_B+SEG_C+      SEG_E+SEG_F      ,     // Displays "M"
-              SEG_C+      SEG_E+      SEG_G,     // Displays "n"
-              SEG_C+SEG_D+SEG_E+      SEG_G,     // Displays "o"
-  SEG_A+SEG_B+            SEG_E+SEG_F+SEG_G,     // Displays "P"
-  SEG_A+SEG_B+SEG_C+            SEG_F+SEG_G,     // Displays "q"
-                          SEG_E+      SEG_G,     // Displays "r"
-  SEG_A+      SEG_C+SEG_D+      SEG_F+SEG_G,     // Displays "S" same as 5
-                    SEG_D+SEG_E+SEG_F+SEG_G,     // Displays "t"
-              SEG_C+SEG_D+SEG_E            ,     // Displays "u"
-              SEG_C+SEG_D+SEG_E            ,     // Displays "v" same as u
-        SEG_B+SEG_C+SEG_D+SEG_E+SEG_F+SEG_G,     // Displays "W"
-        SEG_B+SEG_C+     +SEG_E+SEG_F+SEG_G,     // Displays "X" as H
-        SEG_B+SEG_C+SEG_D+      SEG_F+SEG_G,     // Displays "Y"
-  SEG_A+SEG_B+      SEG_D+SEG_E+      SEG_G,     // Displays "Z" same as 2
+/* *************************************************************************************************
+ *
+ *	Copyright (C) 2009 Texas Instruments Incorporated - http://www.ti.com/ 
+ *	 
+ *	 
+ *	  Redistribution and use in source and binary forms, with or without 
+ *	  modification, are permitted provided that the following conditions 
+ *	  are met:
+ *	
+ *	    Redistributions of source code must retain the above copyright 
+ *	    notice, this list of conditions and the following disclaimer.
+ *	 
+ *	    Redistributions in binary form must reproduce the above copyright
+ *	    notice, this list of conditions and the following disclaimer in the 
+ *	    documentation and/or other materials provided with the   
+ *	    distribution.
+ *	 
+ *	    Neither the name of Texas Instruments Incorporated nor the names of
+ *	    its contributors may be used to endorse or promote products derived
+ *	    from this software without specific prior written permission.
+ *	
+ *	  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+ *	  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ *	  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *	  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+ *	  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+ *	  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ *	  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *	  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *	  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ *	  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ *	  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ************************************************************************************************/
+
+/* Basic display functions. */
+/* ************************************************************************************************* */
+
+/* ************************************************************************************************* */
+/* Include section */
+#include <cc430x613x.h>
+#include <display.h>
+
+/* ************************************************************************************************* */
+/* Global Variable section */
+
+/* Table with memory bit assignment for digits "0" to "9" and characters "A" to "Z" */
+/*   A */
+/* F   B */
+/*   G */
+/* E   C */
+/*   D */
+const uint8_t lcd_font[] = {
+  SEG_A+SEG_B+SEG_C+SEG_D+SEG_E+SEG_F,           /* Displays "0" */
+        SEG_B+SEG_C,                             /* Displays "1" */
+  SEG_A+SEG_B+      SEG_D+SEG_E+      SEG_G,     /* Displays "2" */
+  SEG_A+SEG_B+SEG_C+SEG_D+            SEG_G,     /* Displays "3" */
+        SEG_B+SEG_C+            SEG_F+SEG_G,     /* Displays "4" */
+  SEG_A+      SEG_C+SEG_D+      SEG_F+SEG_G,     /* Displays "5" */
+  SEG_A+      SEG_C+SEG_D+SEG_E+SEG_F+SEG_G,     /* Displays "6" */
+  SEG_A+SEG_B+SEG_C,                             /* Displays "7" */
+  SEG_A+SEG_B+SEG_C+SEG_D+SEG_E+SEG_F+SEG_G,     /* Displays "8" */
+  SEG_A+SEG_B+SEG_C+SEG_D+      SEG_F+SEG_G,     /* Displays "9" */
+  0                                        ,     /* Displays " " (:) */
+  0                                        ,     /* Displays " " (;) */
+  SEG_A+                        SEG_F+SEG_G,     /* Displays "<" as high c */
+                    SEG_D+            SEG_G,     /* Displays "=" */
+  0                                        ,     /* Displays " " (>) */
+  SEG_A+SEG_B+            SEG_E+      SEG_G,     /* Displays "?" */
+  0                                        ,     /* Displays " " (@) */
+  SEG_A+SEG_B+SEG_C+      SEG_E+SEG_F+SEG_G,     /* Displays "A" */
+              SEG_C+SEG_D+SEG_E+SEG_F+SEG_G,     /* Displays "b" */
+                    SEG_D+SEG_E+      SEG_G,     /* Displays "c" */
+        SEG_B+SEG_C+SEG_D+SEG_E+      SEG_G,     /* Displays "d" */
+  SEG_A+           +SEG_D+SEG_E+SEG_F+SEG_G,     /* Displays "E" */
+  SEG_A+                  SEG_E+SEG_F+SEG_G,     /* Displays "f" */
+  SEG_A+SEG_B+SEG_C+SEG_D+      SEG_F+SEG_G,     /* Displays "g" same as 9 */
+              SEG_C+      SEG_E+SEG_F+SEG_G,     /* Displays "h" */
+                          SEG_E            ,     /* Displays "i" */
+  SEG_A+SEG_B+SEG_C+SEG_D                  ,     /* Displays "J" */
+  		     		SEG_D+      SEG_F+SEG_G,     /* Displays "k" */
+                    SEG_D+SEG_E+SEG_F      ,     /* Displays "L" */
+  SEG_A+SEG_B+SEG_C+      SEG_E+SEG_F      ,     /* Displays "M" */
+              SEG_C+      SEG_E+      SEG_G,     /* Displays "n" */
+              SEG_C+SEG_D+SEG_E+      SEG_G,     /* Displays "o" */
+  SEG_A+SEG_B+            SEG_E+SEG_F+SEG_G,     /* Displays "P" */
+  SEG_A+SEG_B+SEG_C+            SEG_F+SEG_G,     /* Displays "q" */
+                          SEG_E+      SEG_G,     /* Displays "r" */
+  SEG_A+      SEG_C+SEG_D+      SEG_F+SEG_G,     /* Displays "S" same as 5 */
+                    SEG_D+SEG_E+SEG_F+SEG_G,     /* Displays "t" */
+              SEG_C+SEG_D+SEG_E            ,     /* Displays "u" */
+              SEG_C+SEG_D+SEG_E            ,     /* Displays "v" same as u */
+        SEG_B+SEG_C+SEG_D+SEG_E+SEG_F+SEG_G,     /* Displays "W" */
+        SEG_B+SEG_C+     +SEG_E+SEG_F+SEG_G,     /* Displays "X" as H */
+        SEG_B+SEG_C+SEG_D+      SEG_F+SEG_G,     /* Displays "Y" */
+  SEG_A+SEG_B+      SEG_D+SEG_E+      SEG_G,     /* Displays "Z" same as 2 */
 };
 
-
-// Table with memory address for each display element 
-const uint8_t * segments_lcdmem[] =
-{
+/* Table with memory address for each display element  */
+const uint8_t * segments_lcdmem[] = {
 	LCD_SYMB_AM_MEM,
 	LCD_SYMB_PM_MEM,
 	LCD_SYMB_ARROW_UP_MEM,
@@ -158,10 +142,8 @@ const uint8_t * segments_lcdmem[] =
 	LCD_SEG_L2_DP_MEM,
 };
 
-
-// Table with bit mask for each display element 
-const uint8_t segments_bitmask[] =
-{
+/* Table with bit mask for each display element  */
+const uint8_t segments_bitmask[] = {
 	LCD_SYMB_AM_MASK,
 	LCD_SYMB_PM_MASK,
 	LCD_SYMB_ARROW_UP_MASK,
@@ -206,10 +188,10 @@ const uint8_t segments_bitmask[] =
 	LCD_SEG_L2_DP_MASK,
 };
 
-
-// Quick integer to array conversion table for most common integer values
-const uint8_t itoa_conversion_table[][3] =
-{
+/* Quick integer to array conversion table for most common integer values 
+ * discarding this would save aprox. 600 bytes codespace but increase cpu time
+ * for displaying values */
+const uint8_t itoa_conversion_table[][3] = {
 	"000", "001", "002", "003", "004", "005", "006", "007", "008", "009", "010", "011", "012", "013", "014", "015",
 	"016", "017", "018", "019", "020", "021", "022", "023", "024", "025", "026", "027", "028", "029", "030", "031",
 	"032", "033", "034", "035", "036", "037", "038", "039", "040", "041", "042", "043", "044", "045", "046", "047",
@@ -223,4 +205,3 @@ const uint8_t itoa_conversion_table[][3] =
 	"160", "161", "162", "163", "164", "165", "166", "167", "168", "169", "170", "171", "172", "173", "174", "175",
 	"176", "177", "178", "179", "180",
 };
-