serial_lcd_cpp.elf:     file format elf32-avr

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .text         000002f2  00000000  00000000  00000094  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  1 .data         0000000c  00800060  000002f2  00000386  2**0
                  CONTENTS, ALLOC, LOAD, DATA
  2 .bss          00000032  0080006c  0080006c  00000392  2**0
                  ALLOC
  3 .stab         0000069c  00000000  00000000  00000394  2**2
                  CONTENTS, READONLY, DEBUGGING
  4 .stabstr      00000082  00000000  00000000  00000a30  2**0
                  CONTENTS, READONLY, DEBUGGING
  5 .debug_aranges 00000020  00000000  00000000  00000ab2  2**0
                  CONTENTS, READONLY, DEBUGGING
  6 .debug_pubnames 00000115  00000000  00000000  00000ad2  2**0
                  CONTENTS, READONLY, DEBUGGING
  7 .debug_info   00000fd4  00000000  00000000  00000be7  2**0
                  CONTENTS, READONLY, DEBUGGING
  8 .debug_abbrev 0000040f  00000000  00000000  00001bbb  2**0
                  CONTENTS, READONLY, DEBUGGING
  9 .debug_line   000006dc  00000000  00000000  00001fca  2**0
                  CONTENTS, READONLY, DEBUGGING
 10 .debug_frame  00000080  00000000  00000000  000026a8  2**2
                  CONTENTS, READONLY, DEBUGGING
 11 .debug_str    00000772  00000000  00000000  00002728  2**0
                  CONTENTS, READONLY, DEBUGGING
 12 .debug_loc    000001e8  00000000  00000000  00002e9a  2**0
                  CONTENTS, READONLY, DEBUGGING
 13 .debug_ranges 00000048  00000000  00000000  00003082  2**0
                  CONTENTS, READONLY, DEBUGGING

Disassembly of section .text:

00000000 <__vectors>:
   0:	12 c0       	rjmp	.+36     	; 0x26 <__ctors_end>
   2:	2a c0       	rjmp	.+84     	; 0x58 <__bad_interrupt>
   4:	29 c0       	rjmp	.+82     	; 0x58 <__bad_interrupt>
   6:	28 c0       	rjmp	.+80     	; 0x58 <__bad_interrupt>
   8:	27 c0       	rjmp	.+78     	; 0x58 <__bad_interrupt>
   a:	26 c0       	rjmp	.+76     	; 0x58 <__bad_interrupt>
   c:	25 c0       	rjmp	.+74     	; 0x58 <__bad_interrupt>
   e:	24 c1       	rjmp	.+584    	; 0x258 <__vector_7>
  10:	23 c0       	rjmp	.+70     	; 0x58 <__bad_interrupt>
  12:	22 c0       	rjmp	.+68     	; 0x58 <__bad_interrupt>
  14:	21 c0       	rjmp	.+66     	; 0x58 <__bad_interrupt>
  16:	20 c0       	rjmp	.+64     	; 0x58 <__bad_interrupt>
  18:	1f c0       	rjmp	.+62     	; 0x58 <__bad_interrupt>
  1a:	3c c1       	rjmp	.+632    	; 0x294 <__vector_13>
  1c:	1d c0       	rjmp	.+58     	; 0x58 <__bad_interrupt>
  1e:	1c c0       	rjmp	.+56     	; 0x58 <__bad_interrupt>
  20:	1b c0       	rjmp	.+54     	; 0x58 <__bad_interrupt>
  22:	1a c0       	rjmp	.+52     	; 0x58 <__bad_interrupt>
  24:	19 c0       	rjmp	.+50     	; 0x58 <__bad_interrupt>

00000026 <__ctors_end>:
  26:	11 24       	eor	r1, r1
  28:	1f be       	out	0x3f, r1	; 63
  2a:	cf ed       	ldi	r28, 0xDF	; 223
  2c:	cd bf       	out	0x3d, r28	; 61

0000002e <__do_copy_data>:
  2e:	10 e0       	ldi	r17, 0x00	; 0
  30:	a0 e6       	ldi	r26, 0x60	; 96
  32:	b0 e0       	ldi	r27, 0x00	; 0
  34:	e2 ef       	ldi	r30, 0xF2	; 242
  36:	f2 e0       	ldi	r31, 0x02	; 2
  38:	02 c0       	rjmp	.+4      	; 0x3e <.do_copy_data_start>

0000003a <.do_copy_data_loop>:
  3a:	05 90       	lpm	r0, Z+
  3c:	0d 92       	st	X+, r0

0000003e <.do_copy_data_start>:
  3e:	ac 36       	cpi	r26, 0x6C	; 108
  40:	b1 07       	cpc	r27, r17
  42:	d9 f7       	brne	.-10     	; 0x3a <.do_copy_data_loop>

00000044 <__do_clear_bss>:
  44:	10 e0       	ldi	r17, 0x00	; 0
  46:	ac e6       	ldi	r26, 0x6C	; 108
  48:	b0 e0       	ldi	r27, 0x00	; 0
  4a:	01 c0       	rjmp	.+2      	; 0x4e <.do_clear_bss_start>

0000004c <.do_clear_bss_loop>:
  4c:	1d 92       	st	X+, r1

0000004e <.do_clear_bss_start>:
  4e:	ae 39       	cpi	r26, 0x9E	; 158
  50:	b1 07       	cpc	r27, r17
  52:	e1 f7       	brne	.-8      	; 0x4c <.do_clear_bss_loop>
  54:	3c d0       	rcall	.+120    	; 0xce <main>
  56:	4b c1       	rjmp	.+662    	; 0x2ee <_exit>

00000058 <__bad_interrupt>:
  58:	d3 cf       	rjmp	.-90     	; 0x0 <__vectors>

0000005a <_ZN4Uart10waitRxCharEv>:
  
#define UART_UBRR(baud) ((F_CPU+(8*(unsigned long) (baud)))/ (16*((unsigned long) (baud))) - 1)
const prog_uint8_t Uart::BaudLookupTable[] =
  {UART_UBRR(115200), UART_UBRR(38400), UART_UBRR(19200), UART_UBRR(9600)};

unsigned char Uart::waitRxChar (void) {
  5a:	fc 01       	movw	r30, r24
  // waits for next RX character, then return it
  unsigned char tail;
  do {
    tail = sUartRxTail; // explicitly set order of volatile variable access
  5c:	86 2d       	mov	r24, r6
  {UART_UBRR(115200), UART_UBRR(38400), UART_UBRR(19200), UART_UBRR(9600)};

unsigned char Uart::waitRxChar (void) {
  // waits for next RX character, then return it
  unsigned char tail;
  do {
  5e:	95 2d       	mov	r25, r5
    WDTCSR &= ~(1<<WDCE);
    sei();
  }
  
  INLINE_FUNC_DECLARE(static void reset(void)) { 
    wdt_reset(); 
  60:	a8 95       	wdr
  {UART_UBRR(115200), UART_UBRR(38400), UART_UBRR(19200), UART_UBRR(9600)};

unsigned char Uart::waitRxChar (void) {
  // waits for next RX character, then return it
  unsigned char tail;
  do {
  62:	98 17       	cp	r25, r24
  64:	e9 f3       	breq	.-6      	; 0x60 <_ZN4Uart10waitRxCharEv+0x6>
  //  CTS inactive if byte fills buffer after we remove current byte
  cli();
#endif

  // increment tail position 
  if (tail == UART_RX_BUFFER_SIZE-1)
  66:	8f 32       	cpi	r24, 0x2F	; 47
  68:	11 f4       	brne	.+4      	; 0x6e <_ZN4Uart10waitRxCharEv+0x14>
    sUartRxTail = 0;
  6a:	66 24       	eor	r6, r6
  6c:	01 c0       	rjmp	.+2      	; 0x70 <_ZN4Uart10waitRxCharEv+0x16>
  else
    sUartRxTail++;
  6e:	63 94       	inc	r6
#if USE_CTS
  CTS_PORT |= (1<<CTS_PIN); // Ensure CTS is active since just removed a byte
  sei();   // Allow UART ISR to read character and change potentially change CTS
#endif

  return m_UartRxBuf[sUartRxTail];
  70:	e6 0d       	add	r30, r6
  72:	f1 1d       	adc	r31, r1
  74:	80 81       	ld	r24, Z
}
  76:	08 95       	ret

00000078 <_ZN3Lcd8busyWaitEv>:
  LCD_CONTROL_PORT &= ~(1<<LCD_E);
}

unsigned char Lcd::busyWait (void) {
  unsigned char LCDStatus; 
  LCD_DATA_DIR = 0x00; // Set LCD data port to inputs
  78:	17 ba       	out	0x17, r1	; 23
  LCD_CONTROL_PORT |= (1<<LCD_RW);
  7a:	94 9a       	sbi	0x12, 4	; 18
  NOP();
  7c:	00 00       	nop
    WDTCSR &= ~(1<<WDCE);
    sei();
  }
  
  INLINE_FUNC_DECLARE(static void reset(void)) { 
    wdt_reset(); 
  7e:	a8 95       	wdr
  LCD_DATA_DIR = 0x00; // Set LCD data port to inputs
  LCD_CONTROL_PORT |= (1<<LCD_RW);
  NOP();
  do {
    Watchdog::reset();
    LCD_CONTROL_PORT |= (1<<LCD_E);	
  80:	96 9a       	sbi	0x12, 6	; 18
  #else
    #define ENABLE_WAIT() __delay_cycles(4);
  #endif
#elif defined(__GNUC__)
  static __inline__ void _NOP1 (void) { __asm__ volatile ( "nop    " "\n\t" ); }
  static __inline__ void _NOP2 (void) { __asm__ volatile ( "rjmp 1f" "\n\t"  "1:" "\n\t" ); }
  82:	00 c0       	rjmp	.+0      	; 0x84 <_ZN3Lcd8busyWaitEv+0xc>
    ENABLE_WAIT();
    LCDStatus = LCD_DATA_PIN_REG;
  84:	00 c0       	rjmp	.+0      	; 0x86 <_ZN3Lcd8busyWaitEv+0xe>
  86:	96 b3       	in	r25, 0x16	; 22
    LCD_CONTROL_PORT &= ~(1<<LCD_E);
  88:	96 98       	cbi	0x12, 6	; 18
unsigned char Lcd::busyWait (void) {
  unsigned char LCDStatus; 
  LCD_DATA_DIR = 0x00; // Set LCD data port to inputs
  LCD_CONTROL_PORT |= (1<<LCD_RW);
  NOP();
  do {
  8a:	97 fd       	sbrc	r25, 7
  8c:	f8 cf       	rjmp	.-16     	; 0x7e <_ZN3Lcd8busyWaitEv+0x6>
    LCD_CONTROL_PORT |= (1<<LCD_E);	
    ENABLE_WAIT();
    LCDStatus = LCD_DATA_PIN_REG;
    LCD_CONTROL_PORT &= ~(1<<LCD_E);
  } while (LCDStatus & (1<<LCD_BUSY));
  LCD_CONTROL_PORT &= ~(1<<LCD_RW);	
  8e:	94 98       	cbi	0x12, 4	; 18
  LCD_DATA_DIR = 0xFF; // Set LCD data port to default output state
  90:	8f ef       	ldi	r24, 0xFF	; 255
  92:	87 bb       	out	0x17, r24	; 23
  return (LCDStatus);
}   		 
  94:	89 2f       	mov	r24, r25
  96:	08 95       	ret

00000098 <_ZN3Lcd7putCharEh>:
  LCD_CONTROL_PORT &= ~(1<<LCD_E);
  NOP();
  LCD_CONTROL_PORT |= (1<<LCD_RS);
}

void Lcd::putChar (unsigned char c) {
  98:	1f 93       	push	r17
  9a:	16 2f       	mov	r17, r22
  LCD_CONTROL_PORT &= ~(1<<LCD_RS);
  9c:	95 98       	cbi	0x12, 5	; 18
  busyWait();
  9e:	ec df       	rcall	.-40     	; 0x78 <_ZN3Lcd8busyWaitEv>
  LCD_CONTROL_PORT |= (1<<LCD_RS);
  a0:	95 9a       	sbi	0x12, 5	; 18
  LCD_DATA_PORT = c;
  a2:	18 bb       	out	0x18, r17	; 24
  NOP();
  a4:	00 00       	nop
  LCD_CONTROL_PORT |= (1<<LCD_E);
  a6:	96 9a       	sbi	0x12, 6	; 18
  a8:	00 c0       	rjmp	.+0      	; 0xaa <_ZN3Lcd7putCharEh+0x12>
  ENABLE_WAIT();
  LCD_CONTROL_PORT &= ~(1<<LCD_E);
  aa:	00 c0       	rjmp	.+0      	; 0xac <_ZN3Lcd7putCharEh+0x14>
  ac:	96 98       	cbi	0x12, 6	; 18
}
  ae:	1f 91       	pop	r17
  b0:	08 95       	ret

000000b2 <_ZN3Lcd6putCmdEh>:
    }
  }
  MAIN_FUNC_LAST();
}

void Lcd::putCmd (unsigned char Cmd) {
  b2:	1f 93       	push	r17
  b4:	16 2f       	mov	r17, r22
  LCD_CONTROL_PORT &= ~(1<<LCD_RS);
  b6:	95 98       	cbi	0x12, 5	; 18
  busyWait();
  b8:	df df       	rcall	.-66     	; 0x78 <_ZN3Lcd8busyWaitEv>
  LCD_DATA_PORT = Cmd;	
  ba:	18 bb       	out	0x18, r17	; 24
  NOP();
  bc:	00 00       	nop
  LCD_CONTROL_PORT |= (1<<LCD_E);
  be:	96 9a       	sbi	0x12, 6	; 18
  c0:	00 c0       	rjmp	.+0      	; 0xc2 <_ZN3Lcd6putCmdEh+0x10>
  ENABLE_WAIT();
  LCD_CONTROL_PORT &= ~(1<<LCD_E);
  c2:	00 c0       	rjmp	.+0      	; 0xc4 <_ZN3Lcd6putCmdEh+0x12>
  c4:	96 98       	cbi	0x12, 6	; 18
  NOP();
  c6:	00 00       	nop
  LCD_CONTROL_PORT |= (1<<LCD_RS);
  c8:	95 9a       	sbi	0x12, 5	; 18
}
  ca:	1f 91       	pop	r17
  cc:	08 95       	ret

000000ce <main>:
  }
};


MAIN_FUNC() {
  MCUSR = 0; // clear all reset flags
  ce:	14 be       	out	0x34, r1	; 52
    WDTCSR &= ~(1<<WDCE);
    sei();
  }
  
  INLINE_FUNC_DECLARE(static void reset(void)) { 
    wdt_reset(); 
  d0:	a8 95       	wdr

class Watchdog {
public:
  INLINE_FUNC_DECLARE(static void init(void)) {
    reset();
    WDTCSR |= (1<<WDCE)|(1<<WDE); // start timed sequence (keep old prescaler)
  d2:	81 b5       	in	r24, 0x21	; 33
  d4:	88 61       	ori	r24, 0x18	; 24
  d6:	81 bd       	out	0x21, r24	; 33
    WDTCSR = (1<<WDE)|(1<<WDP3)|(1<<WDP0); // 1024K cycles, 8.0sec
  d8:	89 e2       	ldi	r24, 0x29	; 41
  da:	81 bd       	out	0x21, r24	; 33
};
  
class SleepMode {
public:
  INLINE_FUNC_DECLARE(static void initIdleMode(void)) {
    MCUCR &= ~((1<<SM1)|(1<<SM0)); // use idle sleep mode
  dc:	85 b7       	in	r24, 0x35	; 53
  de:	8f 7a       	andi	r24, 0xAF	; 175
  e0:	85 bf       	out	0x35, r24	; 53

public:
  INLINE_FUNC_DECLARE(void init(void)) {
    // setup PWM to run at 1.25ms per interrupt. 
    // This allows 8 levels of brightness at minimum of 100Hz flicker rate.
    TCCR0A = (1<<WGM01); // CTC mode
  e2:	82 e0       	ldi	r24, 0x02	; 2
  e4:	80 bf       	out	0x30, r24	; 48
    TCCR0B = 0; // timer off
  e6:	13 be       	out	0x33, r1	; 51
    OCR0A = 72; // 1.25ms with CLK/256 prescaler @ 14.7456MHz
  e8:	88 e4       	ldi	r24, 0x48	; 72
  ea:	86 bf       	out	0x36, r24	; 54
    TIMSK = (1<<OCIE0A); // Turn on timer0 COMPA intr (all other timer intr off)
  ec:	81 e0       	ldi	r24, 0x01	; 1
  ee:	89 bf       	out	0x39, r24	; 57
#if USE_LED_PWM_IO_MEMBERS
    *m_LedPortPtr &= ~(1<<m_LedPin); // Ensure LED is off during initialization
    *m_LedDirPtr |= (1<<m_LedPin); // Ensure LED is output port
#else
    LED_PORT &= ~(1<<LED_PIN); // Ensure LED is off during initialization
  f0:	91 98       	cbi	0x12, 1	; 18
    LED_DIR |= (1<<LED_PIN); // Ensure LED is output port
  f2:	89 9a       	sbi	0x11, 1	; 17
#endif
    BIT_led_on = 0;  // note that LED is off
  f4:	a0 98       	cbi	0x14, 0	; 20
    ledPwmPattern = 0xFF;  // maximum brightness
  f6:	9f ef       	ldi	r25, 0xFF	; 255
  f8:	93 bb       	out	0x13, r25	; 19
  static const unsigned char m_DATA_8 = 0x30;

public:
  INLINE_FUNC_DECLARE(void init(void)) {
    // Set BAUD_J2:BAUD_J1 PULL-UPS active
    LCD_CONTROL_PORT = (1<<BAUD_J2) | (1<<BAUD_J1);
  fa:	8c e0       	ldi	r24, 0x0C	; 12
  fc:	82 bb       	out	0x12, r24	; 18
    // Set LCD_control BAUD_J2:BAUD_J1 to inputs	
    LCD_CONTROL_DIR = 0xF2;
  fe:	82 ef       	ldi	r24, 0xF2	; 242
 100:	81 bb       	out	0x11, r24	; 17
	__asm__ volatile (
		"1: sbiw %0,1" "\n\t"
		"brne 1b"
		: "=w" (__count)
		: "0" (__count)
	);
 102:	e0 e0       	ldi	r30, 0x00	; 0
 104:	f8 ed       	ldi	r31, 0xD8	; 216
 106:	31 97       	sbiw	r30, 0x01	; 1
 108:	f1 f7       	brne	.-4      	; 0x106 <__stack+0x27>
    
    Delay::millisec(15);
    
    LCD_CONTROL_PORT |= (1<<LCD_RS); // Set LCD_RS HIGH
 10a:	95 9a       	sbi	0x12, 5	; 18
    
    // Initialize the AVR controller I/O
    LCD_DATA_DIR = 0xFF; // Set LCD_DATA_PORT as all outputs
 10c:	97 bb       	out	0x17, r25	; 23
    LCD_DATA_PORT = 0x00; // Set LCD_DATA_PORT to logic low
 10e:	18 ba       	out	0x18, r1	; 24
    
    // Initialize the LCD controller
    LCD_CONTROL_PORT &= ~(1<<LCD_RS);
 110:	95 98       	cbi	0x12, 5	; 18
    
    putChar (m_DATA_8); 
 112:	8d e6       	ldi	r24, 0x6D	; 109
 114:	90 e0       	ldi	r25, 0x00	; 0
 116:	60 e3       	ldi	r22, 0x30	; 48
 118:	bf df       	rcall	.-130    	; 0x98 <_ZN3Lcd7putCharEh>
 11a:	8a e0       	ldi	r24, 0x0A	; 10
 11c:	9b e3       	ldi	r25, 0x3B	; 59
 11e:	01 97       	sbiw	r24, 0x01	; 1
 120:	f1 f7       	brne	.-4      	; 0x11e <__stack+0x3f>
    Delay::millisec(4.1);
    
    putChar (m_DATA_8);
 122:	8d e6       	ldi	r24, 0x6D	; 109
 124:	90 e0       	ldi	r25, 0x00	; 0
 126:	60 e3       	ldi	r22, 0x30	; 48
 128:	b7 df       	rcall	.-146    	; 0x98 <_ZN3Lcd7putCharEh>
 12a:	80 e7       	ldi	r24, 0x70	; 112
 12c:	91 e0       	ldi	r25, 0x01	; 1
 12e:	01 97       	sbiw	r24, 0x01	; 1
 130:	f1 f7       	brne	.-4      	; 0x12e <__stack+0x4f>
    Delay::microsec(100);
    
    putChar (m_DATA_8);
 132:	8d e6       	ldi	r24, 0x6D	; 109
 134:	90 e0       	ldi	r25, 0x00	; 0
 136:	60 e3       	ldi	r22, 0x30	; 48
 138:	af df       	rcall	.-162    	; 0x98 <_ZN3Lcd7putCharEh>
    LCD_CONTROL_PORT |= (1<<LCD_RS);
 13a:	95 9a       	sbi	0x12, 5	; 18
    
    // The display will be out into 8 bit data mode here
    putCmd (m_LINE_8x4); // Set 8 bit data, 4 display lines
 13c:	8d e6       	ldi	r24, 0x6D	; 109
 13e:	90 e0       	ldi	r25, 0x00	; 0
 140:	68 e3       	ldi	r22, 0x38	; 56
 142:	b7 df       	rcall	.-146    	; 0xb2 <_ZN3Lcd6putCmdEh>
    putCmd (m_PWR_ON); // Power up the display
 144:	8d e6       	ldi	r24, 0x6D	; 109
 146:	90 e0       	ldi	r25, 0x00	; 0
 148:	6c e0       	ldi	r22, 0x0C	; 12
 14a:	b3 df       	rcall	.-154    	; 0xb2 <_ZN3Lcd6putCmdEh>
    putCmd (m_CLR_DSP); // Power up the display
 14c:	8d e6       	ldi	r24, 0x6D	; 109
 14e:	90 e0       	ldi	r25, 0x00	; 0
 150:	61 e0       	ldi	r22, 0x01	; 1
 152:	af df       	rcall	.-162    	; 0xb2 <_ZN3Lcd6putCmdEh>
  }

public:
  INLINE_FUNC_DECLARE(void init(void)) {
    // Initialize UART0 
    UCSRB = 0; // Disable while setting baud rate
 154:	1a b8       	out	0x0a, r1	; 10
    UCSRA = 0;
 156:	1b b8       	out	0x0b, r1	; 11
    UCSRC = (1<<UCSZ1) | (1<<UCSZ0); // 8 bit data
 158:	86 e0       	ldi	r24, 0x06	; 6
 15a:	83 b9       	out	0x03, r24	; 3

  INLINE_FUNC_DECLARE(static unsigned char baud()) {
    unsigned char BaudSelectJumpersValue;
  
    // Get BAUD rate jumper settings	   
    BaudSelectJumpersValue  = BAUD_PIN_REG;
 15c:	e0 b3       	in	r30, 0x10	; 16
    BaudSelectJumpersValue &= (1<<BAUD_J2) | (1<<BAUD_J1);
    // BAUD_J2 = PD.3, BAUD_J1 = PD.2
    // This is two bits too far to the left and the array index will
    // increment by 4, instead of 1.
    // Shift BAUD_J2 & BAUD_J1 right by two bit positions for proper array indexing
    BaudSelectJumpersValue = (BaudSelectJumpersValue >> BAUD_J1);
 15e:	ec 70       	andi	r30, 0x0C	; 12
    
    return PGM_READ_BYTE (&BaudLookupTable[BaudSelectJumpersValue]);
 160:	e6 95       	lsr	r30
 162:	e6 95       	lsr	r30
 164:	f0 e0       	ldi	r31, 0x00	; 0
 166:	e8 59       	subi	r30, 0x98	; 152
 168:	ff 4f       	sbci	r31, 0xFF	; 255
 16a:	e4 91       	lpm	r30, Z+
  INLINE_FUNC_DECLARE(void init(void)) {
    // Initialize UART0 
    UCSRB = 0; // Disable while setting baud rate
    UCSRA = 0;
    UCSRC = (1<<UCSZ1) | (1<<UCSZ0); // 8 bit data
    UBRRL = baud();
 16c:	e9 b9       	out	0x09, r30	; 9
    UBRRH = 0; // Set baud rate hi
 16e:	12 b8       	out	0x02, r1	; 2
    UCSRB = (1<<RXEN)|(1<<RXCIE); // RXEN = Enable
 170:	80 e9       	ldi	r24, 0x90	; 144
 172:	8a b9       	out	0x0a, r24	; 10

    // Init circular buffer pointers
    sUartRxHead = 0;
 174:	55 24       	eor	r5, r5
    sUartRxTail = 0;
 176:	66 24       	eor	r6, r6

  gLed.init();
  gLcd.init();
  gUart.init();   // Initialize the AVR USART	

  sei();
 178:	78 94       	sei

  INLINE_FUNC_DECLARE(void stop(void)) {
    TCCR0B = 0;
  }
  INLINE_FUNC_DECLARE(void start(void)) {
    TCCR0B = (1<<CS02);
 17a:	14 e0       	ldi	r17, 0x04	; 4
    return 1;
  }

  INLINE_FUNC_DECLARE(unsigned char charAvail(void)) {
    unsigned char tail = sUartRxTail; // explicitly set order of volatile access
    return (tail != sUartRxHead) ? 1 : 0;
 17c:	65 14       	cp	r6, r5
 17e:	09 f4       	brne	.+2      	; 0x182 <__stack+0xa3>
 180:	4e c0       	rjmp	.+156    	; 0x21e <__stack+0x13f>
  gUart.init();   // Initialize the AVR USART	

  sei();
  while (1) {
    if (gUart.charAvail()) {
      SerialCommandProcessor::processChar (gUart.waitRxChar());
 182:	8e e6       	ldi	r24, 0x6E	; 110
 184:	90 e0       	ldi	r25, 0x00	; 0
 186:	69 df       	rcall	.-302    	; 0x5a <_ZN4Uart10waitRxCharEv>
 188:	68 2f       	mov	r22, r24

public:
  INLINE_FUNC_DECLARE(static void processChar(unsigned char ch)) {
    // avoid use of switch statement as ImageCraft and GCC produce signifcantly
    // more code for a switch statement than a sequence of if/else if
    if (ch == m_LED_SW_OFF) {
 18a:	8d 3f       	cpi	r24, 0xFD	; 253
 18c:	21 f4       	brne	.+8      	; 0x196 <__stack+0xb7>

  INLINE_FUNC_DECLARE(void lampOff(void)) {
#if USE_LED_PWM_IO_MEMBERS
    *m_LedPortPtr &= ~(1<<m_LedPin);;
#else
    LED_PORT &= ~(1<<LED_PIN);;
 18e:	91 98       	cbi	0x12, 1	; 18
    TCCR0B = (1<<CS02);
  }

  INLINE_FUNC_DECLARE(void switchOff(void)) {
    lampOff();
    BIT_led_on = 0;
 190:	a0 98       	cbi	0x14, 0	; 20
    BIT_led_on = 0;  // note that LED is off
    ledPwmPattern = 0xFF;  // maximum brightness
  }

  INLINE_FUNC_DECLARE(void stop(void)) {
    TCCR0B = 0;
 192:	13 be       	out	0x33, r1	; 51
 194:	f3 cf       	rjmp	.-26     	; 0x17c <__stack+0x9d>
  INLINE_FUNC_DECLARE(static void processChar(unsigned char ch)) {
    // avoid use of switch statement as ImageCraft and GCC produce signifcantly
    // more code for a switch statement than a sequence of if/else if
    if (ch == m_LED_SW_OFF) {
      gLed.switchOff();
    } else if (ch == m_LED_SW_ON) {
 196:	8c 3f       	cpi	r24, 0xFC	; 252
 198:	29 f4       	brne	.+10     	; 0x1a4 <__stack+0xc5>
    BIT_led_on = 0;
    stop();
  }

  INLINE_FUNC_DECLARE(void switchOn(void)) {
    BIT_led_on = 1;
 19a:	a0 9a       	sbi	0x14, 0	; 20
    if (ledPwmPattern == 0xFF) { // maximum brightness, no need for PWM
 19c:	83 b3       	in	r24, 0x13	; 19
 19e:	8f 3f       	cpi	r24, 0xFF	; 255
 1a0:	71 f5       	brne	.+92     	; 0x1fe <__stack+0x11f>
 1a2:	28 c0       	rjmp	.+80     	; 0x1f4 <__stack+0x115>
    // more code for a switch statement than a sequence of if/else if
    if (ch == m_LED_SW_OFF) {
      gLed.switchOff();
    } else if (ch == m_LED_SW_ON) {
      gLed.switchOn();
    } else if (ch == m_LED_SET_BRIGHTNESS) {
 1a4:	8b 3f       	cpi	r24, 0xFB	; 251
 1a6:	69 f5       	brne	.+90     	; 0x202 <__stack+0x123>
      // read next byte which will be brightness
      gLed.setBrightness(gUart.waitRxChar());
 1a8:	8e e6       	ldi	r24, 0x6E	; 110
 1aa:	90 e0       	ldi	r25, 0x00	; 0
 1ac:	56 df       	rcall	.-340    	; 0x5a <_ZN4Uart10waitRxCharEv>
      start();
    }
  }

  INLINE_FUNC_DECLARE(void setBrightness(unsigned char brightness)) {
    if (brightness == 0) { // turn backlight off for 0 brightness
 1ae:	88 23       	and	r24, r24
 1b0:	39 f4       	brne	.+14     	; 0x1c0 <__stack+0xe1>
      if (BIT_led_on) {
 1b2:	a0 9b       	sbis	0x14, 0	; 20
 1b4:	e3 cf       	rjmp	.-58     	; 0x17c <__stack+0x9d>
    BIT_led_on = 0;  // note that LED is off
    ledPwmPattern = 0xFF;  // maximum brightness
  }

  INLINE_FUNC_DECLARE(void stop(void)) {
    TCCR0B = 0;
 1b6:	13 be       	out	0x33, r1	; 51

  INLINE_FUNC_DECLARE(void setBrightness(unsigned char brightness)) {
    if (brightness == 0) { // turn backlight off for 0 brightness
      if (BIT_led_on) {
        stop();
        ledPwmPattern = 0;
 1b8:	13 ba       	out	0x13, r1	; 19
        ledPwmCycling = 0;
 1ba:	77 24       	eor	r7, r7

  INLINE_FUNC_DECLARE(void lampOff(void)) {
#if USE_LED_PWM_IO_MEMBERS
    *m_LedPortPtr &= ~(1<<m_LedPin);;
#else
    LED_PORT &= ~(1<<LED_PIN);;
 1bc:	91 98       	cbi	0x12, 1	; 18
 1be:	de cf       	rjmp	.-68     	; 0x17c <__stack+0x9d>
        lampOff();
      }
      return;
    }

    unsigned char ledPwmPos = (brightness * (LED_BRIGHTNESS_LEVELS-1) + 127) >> 8; 
 1c0:	90 e0       	ldi	r25, 0x00	; 0
 1c2:	67 e0       	ldi	r22, 0x07	; 7
 1c4:	70 e0       	ldi	r23, 0x00	; 0
 1c6:	81 d0       	rcall	.+258    	; 0x2ca <__mulhi3>
 1c8:	81 58       	subi	r24, 0x81	; 129
 1ca:	9f 4f       	sbci	r25, 0xFF	; 255
 1cc:	89 2f       	mov	r24, r25
 1ce:	99 0f       	add	r25, r25
 1d0:	99 0b       	sbc	r25, r25
 1d2:	98 2f       	mov	r25, r24
 1d4:	88 30       	cpi	r24, 0x08	; 8
 1d6:	08 f0       	brcs	.+2      	; 0x1da <__stack+0xfb>
 1d8:	97 e0       	ldi	r25, 0x07	; 7
    LED_PORT &= ~(1<<LED_PIN);;
#endif
  }

  INLINE_FUNC_DECLARE(unsigned char pwmPattern(unsigned char pos)) {
    return PGM_READ_BYTE (&ledPwmPatterns[pos]);
 1da:	e9 2f       	mov	r30, r25
 1dc:	f0 e0       	ldi	r31, 0x00	; 0
 1de:	e0 5a       	subi	r30, 0xA0	; 160
 1e0:	ff 4f       	sbci	r31, 0xFF	; 255
 1e2:	e4 91       	lpm	r30, Z+

    unsigned char ledPwmPos = (brightness * (LED_BRIGHTNESS_LEVELS-1) + 127) >> 8; 
    // Below is probably not required, but ensures we don't exceed array
    if (ledPwmPos > LED_BRIGHTNESS_LEVELS - 1)
      ledPwmPos = LED_BRIGHTNESS_LEVELS - 1;
    ledPwmPattern = pwmPattern(ledPwmPos);
 1e4:	e3 bb       	out	0x13, r30	; 19
    ledPwmCount = 0;
 1e6:	44 24       	eor	r4, r4
    ledPwmCycling = ledPwmPattern;
 1e8:	83 b3       	in	r24, 0x13	; 19
 1ea:	78 2e       	mov	r7, r24
    if (ledPwmPos >= LED_BRIGHTNESS_LEVELS-1) { // maximum brightness
 1ec:	97 30       	cpi	r25, 0x07	; 7
 1ee:	29 f4       	brne	.+10     	; 0x1fa <__stack+0x11b>
      // don't need PWM to continuously on
      if (BIT_led_on) {
 1f0:	a0 9b       	sbis	0x14, 0	; 20
 1f2:	c4 cf       	rjmp	.-120    	; 0x17c <__stack+0x9d>
    BIT_led_on = 0;  // note that LED is off
    ledPwmPattern = 0xFF;  // maximum brightness
  }

  INLINE_FUNC_DECLARE(void stop(void)) {
    TCCR0B = 0;
 1f4:	13 be       	out	0x33, r1	; 51

  INLINE_FUNC_DECLARE(void lampOn(void)) {
#if USE_LED_PWM_IO_MEMBERS
    *m_LedPortPtr |= (1<<m_LedPin);
#else
    LED_PORT |= (1<<LED_PIN);
 1f6:	91 9a       	sbi	0x12, 1	; 18
 1f8:	c1 cf       	rjmp	.-126    	; 0x17c <__stack+0x9d>
      if (BIT_led_on) {
        stop();
        lampOn();
      }
    } else {
      if (BIT_led_on) {
 1fa:	a0 9b       	sbis	0x14, 0	; 20
 1fc:	bf cf       	rjmp	.-130    	; 0x17c <__stack+0x9d>

  INLINE_FUNC_DECLARE(void stop(void)) {
    TCCR0B = 0;
  }
  INLINE_FUNC_DECLARE(void start(void)) {
    TCCR0B = (1<<CS02);
 1fe:	13 bf       	out	0x33, r17	; 51
 200:	bd cf       	rjmp	.-134    	; 0x17c <__stack+0x9d>
    } else if (ch == m_LED_SW_ON) {
      gLed.switchOn();
    } else if (ch == m_LED_SET_BRIGHTNESS) {
      // read next byte which will be brightness
      gLed.setBrightness(gUart.waitRxChar());
    } else if (ch == m_REG_MODE) {
 202:	8e 3f       	cpi	r24, 0xFE	; 254
 204:	41 f4       	brne	.+16     	; 0x216 <__stack+0x137>
      gLcd.putCmd (gUart.waitRxChar()); // Send LCD command character
 206:	8e e6       	ldi	r24, 0x6E	; 110
 208:	90 e0       	ldi	r25, 0x00	; 0
 20a:	27 df       	rcall	.-434    	; 0x5a <_ZN4Uart10waitRxCharEv>
 20c:	68 2f       	mov	r22, r24
 20e:	8d e6       	ldi	r24, 0x6D	; 109
 210:	90 e0       	ldi	r25, 0x00	; 0
 212:	4f df       	rcall	.-354    	; 0xb2 <_ZN3Lcd6putCmdEh>
 214:	b3 cf       	rjmp	.-154    	; 0x17c <__stack+0x9d>
    } else {
      gLcd.putChar (ch); // Send LCD data character
 216:	8d e6       	ldi	r24, 0x6D	; 109
 218:	90 e0       	ldi	r25, 0x00	; 0
 21a:	3e df       	rcall	.-388    	; 0x98 <_ZN3Lcd7putCharEh>
 21c:	af cf       	rjmp	.-162    	; 0x17c <__stack+0x9d>
    reset();
    WDTCSR |= (1<<WDCE)|(1<<WDE); // start timed sequence (keep old prescaler)
    WDTCSR = (1<<WDE)|(1<<WDP3)|(1<<WDP0); // 1024K cycles, 8.0sec
  }
  INLINE_FUNC_DECLARE(static void off(void)) {
    cli();
 21e:	f8 94       	cli
    WDTCSR &= ~(1<<WDCE);
    sei();
  }
  
  INLINE_FUNC_DECLARE(static void reset(void)) { 
    wdt_reset(); 
 220:	a8 95       	wdr
    WDTCSR = (1<<WDE)|(1<<WDP3)|(1<<WDP0); // 1024K cycles, 8.0sec
  }
  INLINE_FUNC_DECLARE(static void off(void)) {
    cli();
    reset();
    MCUSR &= ~(1<<WDRF); // clear any watchdog interrupt flags
 222:	84 b7       	in	r24, 0x34	; 52
 224:	87 7f       	andi	r24, 0xF7	; 247
 226:	84 bf       	out	0x34, r24	; 52
    WDTCSR |= (1<<WDCE)|(1<<WDE); // start timed sequence (keep old prescaler)
 228:	81 b5       	in	r24, 0x21	; 33
 22a:	88 61       	ori	r24, 0x18	; 24
 22c:	81 bd       	out	0x21, r24	; 33
    WDTCSR &= ~(1<<WDE); // watchdog timer off
 22e:	81 b5       	in	r24, 0x21	; 33
 230:	87 7f       	andi	r24, 0xF7	; 247
 232:	81 bd       	out	0x21, r24	; 33
    sei();
 234:	78 94       	sei
public:
  INLINE_FUNC_DECLARE(static void initIdleMode(void)) {
    MCUCR &= ~((1<<SM1)|(1<<SM0)); // use idle sleep mode
  }
  INLINE_FUNC_DECLARE(static void enterSleep()) {
    sleep_enable();
 236:	85 b7       	in	r24, 0x35	; 53
 238:	80 62       	ori	r24, 0x20	; 32
 23a:	85 bf       	out	0x35, r24	; 53
    sleep_cpu();
 23c:	88 95       	sleep
    sleep_disable();
 23e:	85 b7       	in	r24, 0x35	; 53
 240:	8f 7d       	andi	r24, 0xDF	; 223
 242:	85 bf       	out	0x35, r24	; 53
    WDTCSR &= ~(1<<WDE); // watchdog timer off
    sei();
  }
  
  INLINE_FUNC_DECLARE(static void on(void)) {
    cli();
 244:	f8 94       	cli
    WDTCSR &= ~(1<<WDCE);
    sei();
  }
  
  INLINE_FUNC_DECLARE(static void reset(void)) { 
    wdt_reset(); 
 246:	a8 95       	wdr
  }
  
  INLINE_FUNC_DECLARE(static void on(void)) {
    cli();
    reset();
    WDTCSR |= (1<<WDCE)|(1<<WDE); // start timed sequence (keep old prescaler)
 248:	81 b5       	in	r24, 0x21	; 33
 24a:	88 61       	ori	r24, 0x18	; 24
 24c:	81 bd       	out	0x21, r24	; 33
    WDTCSR &= ~(1<<WDCE);
 24e:	81 b5       	in	r24, 0x21	; 33
 250:	8f 7e       	andi	r24, 0xEF	; 239
 252:	81 bd       	out	0x21, r24	; 33
    sei();
 254:	78 94       	sei
 256:	92 cf       	rjmp	.-220    	; 0x17c <__stack+0x9d>

00000258 <__vector_7>:
  LCD_DATA_DIR = 0xFF; // Set LCD data port to default output state
  return (LCDStatus);
}   		 


ISR(USART_RX_vect)
 258:	1f 92       	push	r1
 25a:	0f 92       	push	r0
 25c:	0f b6       	in	r0, 0x3f	; 63
 25e:	0f 92       	push	r0
 260:	11 24       	eor	r1, r1
 262:	8f 93       	push	r24
 264:	ef 93       	push	r30
 266:	ff 93       	push	r31
{
  gUart.storeChar(UDR);
 268:	8c b1       	in	r24, 0x0c	; 12
#endif
  }

  INLINE_FUNC_DECLARE(unsigned char storeChar(unsigned char rx)) {
    // Calculate next buffer position.
    unsigned char tmphead = sUartRxHead;
 26a:	e5 2d       	mov	r30, r5
    if (tmphead == UART_RX_BUFFER_SIZE-1)
 26c:	ef 32       	cpi	r30, 0x2F	; 47
 26e:	11 f4       	brne	.+4      	; 0x274 <__vector_7+0x1c>
 270:	e0 e0       	ldi	r30, 0x00	; 0
 272:	01 c0       	rjmp	.+2      	; 0x276 <__vector_7+0x1e>
      tmphead = 0;
    else
      tmphead++;
 274:	ef 5f       	subi	r30, 0xFF	; 255
    
    // store in buffer if there is room
    if (tmphead != sUartRxTail) {
 276:	e6 15       	cp	r30, r6
 278:	29 f0       	breq	.+10     	; 0x284 <__vector_7+0x2c>
      sUartRxHead = tmphead;         // Store new index.
 27a:	5e 2e       	mov	r5, r30
      m_UartRxBuf[tmphead] = rx;
 27c:	f0 e0       	ldi	r31, 0x00	; 0
 27e:	e2 59       	subi	r30, 0x92	; 146
 280:	ff 4f       	sbci	r31, 0xFF	; 255
 282:	80 83       	st	Z, r24


ISR(USART_RX_vect)
{
  gUart.storeChar(UDR);
}
 284:	ff 91       	pop	r31
 286:	ef 91       	pop	r30
 288:	8f 91       	pop	r24
 28a:	0f 90       	pop	r0
 28c:	0f be       	out	0x3f, r0	; 63
 28e:	0f 90       	pop	r0
 290:	1f 90       	pop	r1
 292:	18 95       	reti

00000294 <__vector_13>:

ISR(TIMER0_COMPA_vect)
 294:	1f 92       	push	r1
 296:	0f 92       	push	r0
 298:	0f b6       	in	r0, 0x3f	; 63
 29a:	0f 92       	push	r0
 29c:	11 24       	eor	r1, r1
 29e:	8f 93       	push	r24
{  
  sei(); // Okay to allow USART interrupts while controlling LED PWM
 2a0:	78 94       	sei
      }
    }
  }

  INLINE_FUNC_DECLARE(void cyclePwm(void)) {
    if (ledPwmCycling & 0x01) {   // Set current LED state based on cycling variable
 2a2:	70 fe       	sbrs	r7, 0
 2a4:	02 c0       	rjmp	.+4      	; 0x2aa <__vector_13+0x16>

  INLINE_FUNC_DECLARE(void lampOn(void)) {
#if USE_LED_PWM_IO_MEMBERS
    *m_LedPortPtr |= (1<<m_LedPin);
#else
    LED_PORT |= (1<<LED_PIN);
 2a6:	91 9a       	sbi	0x12, 1	; 18
 2a8:	01 c0       	rjmp	.+2      	; 0x2ac <__vector_13+0x18>

  INLINE_FUNC_DECLARE(void lampOff(void)) {
#if USE_LED_PWM_IO_MEMBERS
    *m_LedPortPtr &= ~(1<<m_LedPin);;
#else
    LED_PORT &= ~(1<<LED_PIN);;
 2aa:	91 98       	cbi	0x12, 1	; 18
    } else {
      lampOff();
    }

    // Update cycling variable for next interrupt
    if (ledPwmCount >= LED_BRIGHTNESS_LEVELS-1) {
 2ac:	86 e0       	ldi	r24, 0x06	; 6
 2ae:	84 15       	cp	r24, r4
 2b0:	20 f4       	brcc	.+8      	; 0x2ba <__vector_13+0x26>
      ledPwmCount = 0;
 2b2:	44 24       	eor	r4, r4
      ledPwmCycling = ledPwmPattern;
 2b4:	83 b3       	in	r24, 0x13	; 19
 2b6:	78 2e       	mov	r7, r24
 2b8:	02 c0       	rjmp	.+4      	; 0x2be <__vector_13+0x2a>
    } else {
      ledPwmCount++;
 2ba:	43 94       	inc	r4
      ledPwmCycling >>= 1;
 2bc:	76 94       	lsr	r7
ISR(TIMER0_COMPA_vect)
{  
  sei(); // Okay to allow USART interrupts while controlling LED PWM

  gLed.cyclePwm();
}
 2be:	8f 91       	pop	r24
 2c0:	0f 90       	pop	r0
 2c2:	0f be       	out	0x3f, r0	; 63
 2c4:	0f 90       	pop	r0
 2c6:	1f 90       	pop	r1
 2c8:	18 95       	reti

000002ca <__mulhi3>:
 2ca:	55 27       	eor	r21, r21
 2cc:	00 24       	eor	r0, r0

000002ce <__mulhi3_loop>:
 2ce:	80 ff       	sbrs	r24, 0
 2d0:	02 c0       	rjmp	.+4      	; 0x2d6 <__mulhi3_skip1>
 2d2:	06 0e       	add	r0, r22
 2d4:	57 1f       	adc	r21, r23

000002d6 <__mulhi3_skip1>:
 2d6:	66 0f       	add	r22, r22
 2d8:	77 1f       	adc	r23, r23
 2da:	61 15       	cp	r22, r1
 2dc:	71 05       	cpc	r23, r1
 2de:	21 f0       	breq	.+8      	; 0x2e8 <__mulhi3_exit>
 2e0:	96 95       	lsr	r25
 2e2:	87 95       	ror	r24
 2e4:	00 97       	sbiw	r24, 0x00	; 0
 2e6:	99 f7       	brne	.-26     	; 0x2ce <__mulhi3_loop>

000002e8 <__mulhi3_exit>:
 2e8:	95 2f       	mov	r25, r21
 2ea:	80 2d       	mov	r24, r0
 2ec:	08 95       	ret

000002ee <_exit>:
 2ee:	f8 94       	cli

000002f0 <__stop_program>:
 2f0:	ff cf       	rjmp	.-2      	; 0x2f0 <__stop_program>