serial_lcd.elf:     file format elf32-avr

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .text         000002aa  00000000  00000000  00000074  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  1 .noinit       00000030  00800060  00800060  0000031e  2**0
                  ALLOC
  2 .stab         0000069c  00000000  00000000  00000320  2**2
                  CONTENTS, READONLY, DEBUGGING
  3 .stabstr      00000082  00000000  00000000  000009bc  2**0
                  CONTENTS, READONLY, DEBUGGING
  4 .debug_aranges 00000050  00000000  00000000  00000a3e  2**0
                  CONTENTS, READONLY, DEBUGGING
  5 .debug_pubnames 0000003a  00000000  00000000  00000a8e  2**0
                  CONTENTS, READONLY, DEBUGGING
  6 .debug_info   00000765  00000000  00000000  00000ac8  2**0
                  CONTENTS, READONLY, DEBUGGING
  7 .debug_abbrev 0000026d  00000000  00000000  0000122d  2**0
                  CONTENTS, READONLY, DEBUGGING
  8 .debug_line   0000068a  00000000  00000000  0000149a  2**0
                  CONTENTS, READONLY, DEBUGGING
  9 .debug_frame  00000080  00000000  00000000  00001b24  2**2
                  CONTENTS, READONLY, DEBUGGING
 10 .debug_str    00000298  00000000  00000000  00001ba4  2**0
                  CONTENTS, READONLY, DEBUGGING
 11 .debug_loc    000001cd  00000000  00000000  00001e3c  2**0
                  CONTENTS, READONLY, DEBUGGING
 12 .debug_ranges 000000a8  00000000  00000000  00002009  2**0
                  CONTENTS, READONLY, DEBUGGING

Disassembly of section .text:

00000000 <__vectors>:
   0:	18 c0       	rjmp	.+48     	; 0x32 <__ctors_end>
   2:	1d c0       	rjmp	.+58     	; 0x3e <__bad_interrupt>
   4:	1c c0       	rjmp	.+56     	; 0x3e <__bad_interrupt>
   6:	1b c0       	rjmp	.+54     	; 0x3e <__bad_interrupt>
   8:	1a c0       	rjmp	.+52     	; 0x3e <__bad_interrupt>
   a:	19 c0       	rjmp	.+50     	; 0x3e <__bad_interrupt>
   c:	18 c0       	rjmp	.+48     	; 0x3e <__bad_interrupt>
   e:	42 c0       	rjmp	.+132    	; 0x94 <__vector_7>
  10:	16 c0       	rjmp	.+44     	; 0x3e <__bad_interrupt>
  12:	15 c0       	rjmp	.+42     	; 0x3e <__bad_interrupt>
  14:	14 c0       	rjmp	.+40     	; 0x3e <__bad_interrupt>
  16:	13 c0       	rjmp	.+38     	; 0x3e <__bad_interrupt>
  18:	12 c0       	rjmp	.+36     	; 0x3e <__bad_interrupt>
  1a:	18 c1       	rjmp	.+560    	; 0x24c <__vector_13>
  1c:	10 c0       	rjmp	.+32     	; 0x3e <__bad_interrupt>
  1e:	0f c0       	rjmp	.+30     	; 0x3e <__bad_interrupt>
  20:	0e c0       	rjmp	.+28     	; 0x3e <__bad_interrupt>
  22:	0d c0       	rjmp	.+26     	; 0x3e <__bad_interrupt>
  24:	0c c0       	rjmp	.+24     	; 0x3e <__bad_interrupt>

00000026 <BaudLookupTable>:
  26:	07 17 2f 5f                                         ../_

0000002a <ledPwmPatterns>:
  2a:	10 11 4a 55 5d ee 7f ff                             ..JU]...

00000032 <__ctors_end>:
  32:	11 24       	eor	r1, r1
  34:	1f be       	out	0x3f, r1	; 63
  36:	cf ed       	ldi	r28, 0xDF	; 223
  38:	cd bf       	out	0x3d, r28	; 61
  3a:	5c d0       	rcall	.+184    	; 0xf4 <main>
  3c:	34 c1       	rjmp	.+616    	; 0x2a6 <_exit>

0000003e <__bad_interrupt>:
  3e:	e0 cf       	rjmp	.-64     	; 0x0 <__vectors>

00000040 <LcdBusyWait>:
  LCD_CONTROL_PORT &= ~(1<<LCD_E);
}

unsigned char LcdBusyWait (void) {
  unsigned char LCDStatus;
  LCD_DATA_DIR = 0x00; // Set LCD data port to inputs
  40:	17 ba       	out	0x17, r1	; 23
  LCD_CONTROL_PORT &= ~(1<<LCD_RS); // Set display to "Register mode"
  42:	95 98       	cbi	0x12, 5	; 18
  LCD_CONTROL_PORT |= (1<<LCD_RW); // Put the display in the read mode
  44:	94 9a       	sbi	0x12, 4	; 18
  NOP();
  46:	00 00       	nop
  do {
    wdt_reset();
  48:	a8 95       	wdr
    LCD_CONTROL_PORT |= (1<<LCD_E);
  4a:	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" ); }
  4c:	00 c0       	rjmp	.+0      	; 0x4e <LcdBusyWait+0xe>
    ENABLE_WAIT();
    LCDStatus = LCD_DATA_PIN_REG;
  4e:	00 c0       	rjmp	.+0      	; 0x50 <LcdBusyWait+0x10>
  50:	96 b3       	in	r25, 0x16	; 22
    LCD_CONTROL_PORT &= ~(1<<LCD_E);
  52:	96 98       	cbi	0x12, 6	; 18
  } while (LCDStatus & (1<<LCD_BUSY));
  54:	97 fd       	sbrc	r25, 7
  56:	f8 cf       	rjmp	.-16     	; 0x48 <LcdBusyWait+0x8>
  LCD_CONTROL_PORT &= ~(1<<LCD_RW); // Put display in write mode
  58:	94 98       	cbi	0x12, 4	; 18
  LCD_DATA_DIR = 0xFF; // Set LCD data port to outputs
  5a:	8f ef       	ldi	r24, 0xFF	; 255
  5c:	87 bb       	out	0x17, r24	; 23
  return (LCDStatus);
}
  5e:	89 2f       	mov	r24, r25
  60:	08 95       	ret

00000062 <LcdWriteData>:
  LCD_CONTROL_PORT &= ~(1<<LCD_E);
  NOP();
  LCD_CONTROL_PORT |= (1<<LCD_RS); // Set display to "Character mode"
}

void LcdWriteData (unsigned char c) {
  62:	1f 93       	push	r17
  64:	18 2f       	mov	r17, r24
  LcdBusyWait();
  66:	ec df       	rcall	.-40     	; 0x40 <LcdBusyWait>
  LCD_CONTROL_PORT |= (1<<LCD_RS); // Set display to "Character Mode"
  68:	95 9a       	sbi	0x12, 5	; 18
  LCD_DATA_PORT = c;
  6a:	18 bb       	out	0x18, r17	; 24
  NOP();
  6c:	00 00       	nop
  LCD_CONTROL_PORT |= (1<<LCD_E);
  6e:	96 9a       	sbi	0x12, 6	; 18
  70:	00 c0       	rjmp	.+0      	; 0x72 <LcdWriteData+0x10>
  ENABLE_WAIT();
  LCD_CONTROL_PORT &= ~(1<<LCD_E);
  72:	00 c0       	rjmp	.+0      	; 0x74 <LcdWriteData+0x12>
  74:	96 98       	cbi	0x12, 6	; 18
}
  76:	1f 91       	pop	r17
  78:	08 95       	ret

0000007a <LcdWriteCmd>:
    }
  }
  MAIN_FUNC_LAST();
}

void LcdWriteCmd (unsigned char Cmd) {
  7a:	1f 93       	push	r17
  7c:	18 2f       	mov	r17, r24
  LcdBusyWait();
  7e:	e0 df       	rcall	.-64     	; 0x40 <LcdBusyWait>
  LCD_DATA_PORT = Cmd;  // BusyWait leaves RS low in "Register mode"
  80:	18 bb       	out	0x18, r17	; 24
  NOP();
  82:	00 00       	nop
  LCD_CONTROL_PORT |= (1<<LCD_E);
  84:	96 9a       	sbi	0x12, 6	; 18
  86:	00 c0       	rjmp	.+0      	; 0x88 <LcdWriteCmd+0xe>
  ENABLE_WAIT();
  LCD_CONTROL_PORT &= ~(1<<LCD_E);
  88:	00 c0       	rjmp	.+0      	; 0x8a <LcdWriteCmd+0x10>
  8a:	96 98       	cbi	0x12, 6	; 18
  NOP();
  8c:	00 00       	nop
  LCD_CONTROL_PORT |= (1<<LCD_RS); // Set display to "Character mode"
  8e:	95 9a       	sbi	0x12, 5	; 18
}
  90:	1f 91       	pop	r17
  92:	08 95       	ret

00000094 <__vector_7>:
#pragma interrupt_handler usart_rx_handler:iv_USART0_RXC
void usart_rx_handler(void)
#else
ISR(USART_RX_vect)
#endif
{
  94:	1f 92       	push	r1
  96:	0f 92       	push	r0
  98:	0f b6       	in	r0, 0x3f	; 63
  9a:	0f 92       	push	r0
  9c:	11 24       	eor	r1, r1
  9e:	8f 93       	push	r24
  a0:	ef 93       	push	r30
  a2:	ff 93       	push	r31
  UartStoreRx(UDR);
  a4:	8c b1       	in	r24, 0x0c	; 12

INLINE_FUNC_DECLARE(static void UartStoreRx (uint8_t rx));
static inline void UartStoreRx (uint8_t rx) {
  unsigned char tmphead;

  if (UCSRA & (1<<FE)) {
  a6:	5c 99       	sbic	0x0b, 4	; 11
  a8:	0d c0       	rjmp	.+26     	; 0xc4 <__vector_7+0x30>
    // some applications may benefit from addind error notification for serial port data overruns
  }
#endif

  // Calculate next buffer position.
  tmphead = sUartRxHead;
  aa:	e5 2d       	mov	r30, r5
  if (tmphead == UART_RX_BUFFER_SIZE-1)
  ac:	ef 32       	cpi	r30, 0x2F	; 47
  ae:	11 f4       	brne	.+4      	; 0xb4 <__vector_7+0x20>
  b0:	e0 e0       	ldi	r30, 0x00	; 0
  b2:	01 c0       	rjmp	.+2      	; 0xb6 <__vector_7+0x22>
    tmphead = 0;
  else
    tmphead++;
  b4:	ef 5f       	subi	r30, 0xFF	; 255
  // store in buffer if there is room
  if (tmphead != sUartRxTail) {
  b6:	e6 15       	cp	r30, r6
  b8:	29 f0       	breq	.+10     	; 0xc4 <__vector_7+0x30>
    sUartRxHead = tmphead;         // Store new index.
  ba:	5e 2e       	mov	r5, r30
    sUartRxBuf[tmphead] = rx;
  bc:	f0 e0       	ldi	r31, 0x00	; 0
  be:	e0 5a       	subi	r30, 0xA0	; 160
  c0:	ff 4f       	sbci	r31, 0xFF	; 255
  c2:	80 83       	st	Z, r24
#else
ISR(USART_RX_vect)
#endif
{
  UartStoreRx(UDR);
}
  c4:	ff 91       	pop	r31
  c6:	ef 91       	pop	r30
  c8:	8f 91       	pop	r24
  ca:	0f 90       	pop	r0
  cc:	0f be       	out	0x3f, r0	; 63
  ce:	0f 90       	pop	r0
  d0:	1f 90       	pop	r1
  d2:	18 95       	reti

000000d4 <WaitRxChar>:

static unsigned char WaitRxChar (void) {
  // waits for next RX character, then return it
  unsigned char tail;
  do {
    tail = sUartRxTail; // explicitly set order of volatile variable access
  d4:	86 2d       	mov	r24, r6
    wdt_reset();
  } while (sUartRxHead == tail); // while buffer is empty
  d6:	95 2d       	mov	r25, r5
static unsigned char WaitRxChar (void) {
  // waits for next RX character, then return it
  unsigned char tail;
  do {
    tail = sUartRxTail; // explicitly set order of volatile variable access
    wdt_reset();
  d8:	a8 95       	wdr
  } while (sUartRxHead == tail); // while buffer is empty
  da:	98 17       	cp	r25, r24
  dc:	e9 f3       	breq	.-6      	; 0xd8 <WaitRxChar+0x4>
  // CTS inactive if byte fills buffer after we remove current byte
  cli();
#endif

  // increment tail position
  if (tail == UART_RX_BUFFER_SIZE-1)
  de:	8f 32       	cpi	r24, 0x2F	; 47
  e0:	11 f4       	brne	.+4      	; 0xe6 <__stack+0x7>
    sUartRxTail = 0;
  e2:	66 24       	eor	r6, r6
  e4:	01 c0       	rjmp	.+2      	; 0xe8 <__stack+0x9>
  else
    sUartRxTail++;
  e6:	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 sUartRxBuf[sUartRxTail];
  e8:	e6 2d       	mov	r30, r6
  ea:	f0 e0       	ldi	r31, 0x00	; 0
  ec:	e0 5a       	subi	r30, 0xA0	; 160
  ee:	ff 4f       	sbci	r31, 0xFF	; 255
  f0:	80 81       	ld	r24, Z
}
  f2:	08 95       	ret

000000f4 <main>:
  LcdWriteCmd (LCD_ON); // Power up the display
  LcdWriteCmd (LCD_CLR); // Power up the display
}

MAIN_FUNC() {
  MCUSR = 0; // clear all reset flags
  f4:	14 be       	out	0x34, r1	; 52

  wdt_reset();
  f6:	a8 95       	wdr
#if defined(__CODEVISIONAVR__)
#pragma optsize-
#endif
  WDTCSR |= (1<<WDCE)|(1<<WDE); // start timed sequence (keep old prescaler)
  f8:	81 b5       	in	r24, 0x21	; 33
  fa:	88 61       	ori	r24, 0x18	; 24
  fc:	81 bd       	out	0x21, r24	; 33
  WDTCSR = (1<<WDE)|(1<<WDP3)|(1<<WDP0); // 1024K cycles, 8.0sec
  fe:	89 e2       	ldi	r24, 0x29	; 41
 100:	81 bd       	out	0x21, r24	; 33
#if defined(__CODEVISIONAVR__) && defined(_OPTIMIZE_SIZE_)
#pragma optsize+
#endif
  MCUCR &= ~((1<<SM1)|(1<<SM0)); // use idle sleep mode
 102:	85 b7       	in	r24, 0x35	; 53
 104:	8f 7a       	andi	r24, 0xAF	; 175
 106:	85 bf       	out	0x35, r24	; 53

INLINE_FUNC_DECLARE(static void LedPwmInit (void));
static inline void LedPwmInit (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
 108:	82 e0       	ldi	r24, 0x02	; 2
 10a:	80 bf       	out	0x30, r24	; 48
  TCCR0B = 0;           // timer off
 10c:	13 be       	out	0x33, r1	; 51
  OCR0A = 72;           // 1.25ms with CLK/256 prescaler @ 14.7456MHz
 10e:	88 e4       	ldi	r24, 0x48	; 72
 110:	86 bf       	out	0x36, r24	; 54
  TIMSK = (1<<OCIE0A);  // Turn on timer0 COMPA intr (all other timer intr off)
 112:	81 e0       	ldi	r24, 0x01	; 1
 114:	89 bf       	out	0x39, r24	; 57
  LED_PORT &= ~(1<<LED_PIN); // Ensure LED is off during initialization
 116:	91 98       	cbi	0x12, 1	; 18
  LED_DIR |= (1<<LED_PIN);   // Ensure LED is output direction
 118:	89 9a       	sbi	0x11, 1	; 17
  BACKLIGHT_OFF();       // note that LED is off
 11a:	a0 98       	cbi	0x14, 0	; 20
  ledPwmPattern = 0xFF; // maximum brightness
 11c:	9f ef       	ldi	r25, 0xFF	; 255
 11e:	93 bb       	out	0x13, r25	; 19


INLINE_FUNC_DECLARE(static void LcdInit (void));
static inline void LcdInit (void) {
  // Set BAUD_J2:BAUD_J1 PULL-UPS active
  LCD_CONTROL_PORT = (1<<BAUD_J2) | (1<<BAUD_J1);
 120:	8c e0       	ldi	r24, 0x0C	; 12
 122:	82 bb       	out	0x12, r24	; 18
  // Set LCD_control BAUD_J2:BAUD_J1 to inputs
  LCD_CONTROL_DIR = 0xF2;
 124:	82 ef       	ldi	r24, 0xF2	; 242
 126:	81 bb       	out	0x11, r24	; 17
    milliseconds can be achieved.
 */
void
_delay_loop_2(uint16_t __count)
{
	__asm__ volatile (
 128:	e0 e0       	ldi	r30, 0x00	; 0
 12a:	f8 ed       	ldi	r31, 0xD8	; 216
 12c:	31 97       	sbiw	r30, 0x01	; 1
 12e:	f1 f7       	brne	.-4      	; 0x12c <main+0x38>

  _delay_us(15000);
  LCD_CONTROL_PORT |= (1<<LCD_RS); // Set LCD_RS HIGH
 130:	95 9a       	sbi	0x12, 5	; 18

  // Initialize the LCD Data AVR I/O
  LCD_DATA_DIR = 0xFF; // Set LCD_DATA_PORT as all outputs
 132:	97 bb       	out	0x17, r25	; 23
  LCD_DATA_PORT = 0x00; // Set LCD_DATA_PORT to logic low
 134:	18 ba       	out	0x18, r1	; 24

  // Initialize the LCD controller
  LCD_CONTROL_PORT &= ~(1<<LCD_RS);
 136:	95 98       	cbi	0x12, 5	; 18
  LcdWriteData (DATA_8);
 138:	80 e3       	ldi	r24, 0x30	; 48
 13a:	93 df       	rcall	.-218    	; 0x62 <LcdWriteData>
 13c:	8a e0       	ldi	r24, 0x0A	; 10
 13e:	9b e3       	ldi	r25, 0x3B	; 59
 140:	01 97       	sbiw	r24, 0x01	; 1
 142:	f1 f7       	brne	.-4      	; 0x140 <main+0x4c>

  _delay_us(4100);
  LcdWriteData (DATA_8);
 144:	80 e3       	ldi	r24, 0x30	; 48
 146:	8d df       	rcall	.-230    	; 0x62 <LcdWriteData>
 148:	80 e7       	ldi	r24, 0x70	; 112
 14a:	91 e0       	ldi	r25, 0x01	; 1
 14c:	01 97       	sbiw	r24, 0x01	; 1
 14e:	f1 f7       	brne	.-4      	; 0x14c <main+0x58>

  _delay_us(100);
  LcdWriteData (DATA_8);
 150:	80 e3       	ldi	r24, 0x30	; 48
 152:	87 df       	rcall	.-242    	; 0x62 <LcdWriteData>
  LCD_CONTROL_PORT |= (1<<LCD_RS);
 154:	95 9a       	sbi	0x12, 5	; 18

  // The display will be out into 8 bit data mode here
  LcdWriteCmd (LCD_8_Bit | LCD_4_Line); // Set 8 bit data, 4 display lines
 156:	88 e3       	ldi	r24, 0x38	; 56
 158:	90 df       	rcall	.-224    	; 0x7a <LcdWriteCmd>
  LcdWriteCmd (LCD_ON); // Power up the display
 15a:	8c e0       	ldi	r24, 0x0C	; 12
 15c:	8e df       	rcall	.-228    	; 0x7a <LcdWriteCmd>
  LcdWriteCmd (LCD_CLR); // Power up the display
 15e:	81 e0       	ldi	r24, 0x01	; 1
 160:	8c df       	rcall	.-232    	; 0x7a <LcdWriteCmd>


INLINE_FUNC_DECLARE(static void UsartInit (void));
static inline void UsartInit(void) {
  // Initialize USART
  UCSRB = 0; // Disable while setting baud rate
 162:	1a b8       	out	0x0a, r1	; 10
  UCSRA = 0;
 164:	1b b8       	out	0x0b, r1	; 11
  UCSRC = (1<<UCSZ1) | (1<<UCSZ0); // 8 bit data
 166:	86 e0       	ldi	r24, 0x06	; 6
 168:	83 b9       	out	0x03, r24	; 3
= {BAUD_115200, BAUD_38400, BAUD_19200, BAUD_9600};

INLINE_FUNC_DECLARE(static unsigned char GetUsartBaud (void));
static inline unsigned char GetUsartBaud (void) {
  // Get BAUD rate jumper settings
  unsigned char BaudSelectJumpersValue  = BAUD_PIN_REG;
 16a:	e0 b3       	in	r30, 0x10	; 16
  // Mask off unwanted bits
  BaudSelectJumpersValue &= (1<<BAUD_J2) | (1<<BAUD_J1);
 16c:	ec 70       	andi	r30, 0x0C	; 12
  // 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);

  return PGM_READ_BYTE (&BaudLookupTable[BaudSelectJumpersValue]);
 16e:	e6 95       	lsr	r30
 170:	e6 95       	lsr	r30
 172:	f0 e0       	ldi	r31, 0x00	; 0
 174:	ea 5d       	subi	r30, 0xDA	; 218
 176:	ff 4f       	sbci	r31, 0xFF	; 255
 178:	e4 91       	lpm	r30, Z+
static inline void UsartInit(void) {
  // Initialize USART
  UCSRB = 0; // Disable while setting baud rate
  UCSRA = 0;
  UCSRC = (1<<UCSZ1) | (1<<UCSZ0); // 8 bit data
  UBRRL = GetUsartBaud (); // Set baud rate
 17a:	e9 b9       	out	0x09, r30	; 9
  UBRRH = 0; // Set baud rate hi
 17c:	12 b8       	out	0x02, r1	; 2
  UCSRB = (1<<RXEN)|(1<<RXCIE); // RXEN = Enable
 17e:	80 e9       	ldi	r24, 0x90	; 144
 180:	8a b9       	out	0x0a, r24	; 10
  sUartRxHead = 0; // register variable, need to explicitly zero
 182:	55 24       	eor	r5, r5
  sUartRxTail = 0; // register variable, need to explicitly zero
 184:	66 24       	eor	r6, r6
  LcdInit ();

  // Initialize the AVR USART
  UsartInit ();

  sei();
 186:	78 94       	sei
  TCCR0B = 0;
}

INLINE_FUNC_DECLARE(static void LedTimerStart (void));
static inline void LedTimerStart (void) {
  TCCR0B = (1<<CS02); // Start with 256 prescaler
 188:	14 e0       	ldi	r17, 0x04	; 4
  UsartInit ();

  sei();
  while (1) {
    unsigned char tail = sUartRxTail; // explicitly set order of volatile access
    if (tail != sUartRxHead) { // Check if UART RX buffer has a character
 18a:	65 14       	cp	r6, r5
 18c:	09 f4       	brne	.+2      	; 0x190 <main+0x9c>
 18e:	41 c0       	rjmp	.+130    	; 0x212 <main+0x11e>
      unsigned char rx_byte = WaitRxChar();
 190:	a1 df       	rcall	.-190    	; 0xd4 <WaitRxChar>

      // 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 (rx_byte == LED_SW_OFF) {
 192:	8d 3f       	cpi	r24, 0xFD	; 253
 194:	21 f4       	brne	.+8      	; 0x19e <main+0xaa>
  }
}

INLINE_FUNC_DECLARE(static void LedPwmSwitchOff (void));
static inline void LedPwmSwitchOff (void) {
  LED_PORT &= ~(1<<LED_PIN);
 196:	91 98       	cbi	0x12, 1	; 18
  BACKLIGHT_OFF();
 198:	a0 98       	cbi	0x14, 0	; 20

#else
// Using a platform that has proper inline functions
INLINE_FUNC_DECLARE(static void LedTimerStop (void));
static inline void LedTimerStop (void) {
  TCCR0B = 0;
 19a:	13 be       	out	0x33, r1	; 51
 19c:	f6 cf       	rjmp	.-20     	; 0x18a <main+0x96>

      // 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 (rx_byte == LED_SW_OFF) {
        LedPwmSwitchOff();
      } else if (rx_byte == LED_SW_ON) {
 19e:	8c 3f       	cpi	r24, 0xFC	; 252
 1a0:	29 f4       	brne	.+10     	; 0x1ac <main+0xb8>
  LedTimerStop();
}

INLINE_FUNC_DECLARE(static void LedPwmSwitchOn (void));
static inline void LedPwmSwitchOn (void) {
  BACKLIGHT_ON();
 1a2:	a0 9a       	sbi	0x14, 0	; 20
  if (ledPwmPattern == 0xFF) { // maximum brightness, no need for PWM
 1a4:	83 b3       	in	r24, 0x13	; 19
 1a6:	8f 3f       	cpi	r24, 0xFF	; 255
 1a8:	59 f5       	brne	.+86     	; 0x200 <main+0x10c>
 1aa:	25 c0       	rjmp	.+74     	; 0x1f6 <main+0x102>
      // more code for a switch statement than a sequence of if/else if
      if (rx_byte == LED_SW_OFF) {
        LedPwmSwitchOff();
      } else if (rx_byte == LED_SW_ON) {
        LedPwmSwitchOn();
      } else if (rx_byte == LED_SET_BRIGHTNESS) {
 1ac:	8b 3f       	cpi	r24, 0xFB	; 251
 1ae:	51 f5       	brne	.+84     	; 0x204 <main+0x110>
        rx_byte = WaitRxChar();  // read next byte which will be brightness
 1b0:	91 df       	rcall	.-222    	; 0xd4 <WaitRxChar>

INLINE_FUNC_DECLARE(static void LedPwmSetBrightness (unsigned char brightness));
static inline void LedPwmSetBrightness (unsigned char brightness) {
  unsigned char ledPwmPos;

  if (brightness == 0) { // turn backlight off for 0 brightness
 1b2:	88 23       	and	r24, r24
 1b4:	39 f4       	brne	.+14     	; 0x1c4 <main+0xd0>
    if (IS_BACKLIGHT_ON()) {
 1b6:	a0 9b       	sbis	0x14, 0	; 20
 1b8:	e8 cf       	rjmp	.-48     	; 0x18a <main+0x96>

#else
// Using a platform that has proper inline functions
INLINE_FUNC_DECLARE(static void LedTimerStop (void));
static inline void LedTimerStop (void) {
  TCCR0B = 0;
 1ba:	13 be       	out	0x33, r1	; 51
  unsigned char ledPwmPos;

  if (brightness == 0) { // turn backlight off for 0 brightness
    if (IS_BACKLIGHT_ON()) {
      LedTimerStop();
      ledPwmPattern = 0;
 1bc:	13 ba       	out	0x13, r1	; 19
      ledPwmCycling = 0;
 1be:	77 24       	eor	r7, r7
      LED_PORT &= ~(1<<LED_PIN);
 1c0:	91 98       	cbi	0x12, 1	; 18
 1c2:	e3 cf       	rjmp	.-58     	; 0x18a <main+0x96>
    }
    return;
  }

  ledPwmPos = (brightness * (LED_BRIGHTNESS_LEVELS-1) + (unsigned int) 127) >> 8;
 1c4:	90 e0       	ldi	r25, 0x00	; 0
 1c6:	67 e0       	ldi	r22, 0x07	; 7
 1c8:	70 e0       	ldi	r23, 0x00	; 0
 1ca:	5b d0       	rcall	.+182    	; 0x282 <__mulhi3>
 1cc:	81 58       	subi	r24, 0x81	; 129
 1ce:	9f 4f       	sbci	r25, 0xFF	; 255
 1d0:	89 2f       	mov	r24, r25
 1d2:	99 27       	eor	r25, r25
 1d4:	98 2f       	mov	r25, r24
 1d6:	88 30       	cpi	r24, 0x08	; 8
 1d8:	08 f0       	brcs	.+2      	; 0x1dc <main+0xe8>
 1da:	97 e0       	ldi	r25, 0x07	; 7
  // Below is probably not required, but ensures we don't exceed array
  if (ledPwmPos > LED_BRIGHTNESS_LEVELS - 1)
    ledPwmPos = LED_BRIGHTNESS_LEVELS - 1;

  ledPwmPattern = PGM_READ_BYTE (&ledPwmPatterns[ledPwmPos]);
 1dc:	e9 2f       	mov	r30, r25
 1de:	f0 e0       	ldi	r31, 0x00	; 0
 1e0:	e6 5d       	subi	r30, 0xD6	; 214
 1e2:	ff 4f       	sbci	r31, 0xFF	; 255
 1e4:	e4 91       	lpm	r30, Z+
 1e6:	e3 bb       	out	0x13, r30	; 19
  ledPwmCount = 0;
 1e8:	44 24       	eor	r4, r4
  ledPwmCycling = ledPwmPattern;
 1ea:	83 b3       	in	r24, 0x13	; 19
 1ec:	78 2e       	mov	r7, r24
  if (ledPwmPos >= LED_BRIGHTNESS_LEVELS-1) { // maximum brightness
 1ee:	97 30       	cpi	r25, 0x07	; 7
 1f0:	29 f4       	brne	.+10     	; 0x1fc <main+0x108>
    // don't need PWM for continuously on
    if (IS_BACKLIGHT_ON()) {
 1f2:	a0 9b       	sbis	0x14, 0	; 20
 1f4:	ca cf       	rjmp	.-108    	; 0x18a <main+0x96>

#else
// Using a platform that has proper inline functions
INLINE_FUNC_DECLARE(static void LedTimerStop (void));
static inline void LedTimerStop (void) {
  TCCR0B = 0;
 1f6:	13 be       	out	0x33, r1	; 51
  ledPwmCycling = ledPwmPattern;
  if (ledPwmPos >= LED_BRIGHTNESS_LEVELS-1) { // maximum brightness
    // don't need PWM for continuously on
    if (IS_BACKLIGHT_ON()) {
      LedTimerStop();
      LED_PORT |= (1<<LED_PIN);
 1f8:	91 9a       	sbi	0x12, 1	; 18
 1fa:	c7 cf       	rjmp	.-114    	; 0x18a <main+0x96>
    }
  } else {
    if (IS_BACKLIGHT_ON()) {
 1fc:	a0 9b       	sbis	0x14, 0	; 20
 1fe:	c5 cf       	rjmp	.-118    	; 0x18a <main+0x96>
  TCCR0B = 0;
}

INLINE_FUNC_DECLARE(static void LedTimerStart (void));
static inline void LedTimerStart (void) {
  TCCR0B = (1<<CS02); // Start with 256 prescaler
 200:	13 bf       	out	0x33, r17	; 51
 202:	c3 cf       	rjmp	.-122    	; 0x18a <main+0x96>
      } else if (rx_byte == LED_SW_ON) {
        LedPwmSwitchOn();
      } else if (rx_byte == LED_SET_BRIGHTNESS) {
        rx_byte = WaitRxChar();  // read next byte which will be brightness
        LedPwmSetBrightness(rx_byte);
      } else if (rx_byte == REG_MODE) {
 204:	8e 3f       	cpi	r24, 0xFE	; 254
 206:	19 f4       	brne	.+6      	; 0x20e <main+0x11a>
        LcdWriteCmd (WaitRxChar()); // Send LCD command character
 208:	65 df       	rcall	.-310    	; 0xd4 <WaitRxChar>
 20a:	37 df       	rcall	.-402    	; 0x7a <LcdWriteCmd>
 20c:	be cf       	rjmp	.-132    	; 0x18a <main+0x96>
      } else {
        LcdWriteData (rx_byte); // Send LCD data character
 20e:	29 df       	rcall	.-430    	; 0x62 <LcdWriteData>
 210:	bc cf       	rjmp	.-136    	; 0x18a <main+0x96>
      }
    } else {
      // No characters waiting in RX buffer

      cli();
 212:	f8 94       	cli
      wdt_reset();
 214:	a8 95       	wdr
      MCUSR &= ~(1<<WDRF); // clear any watchdog interrupt flags
 216:	84 b7       	in	r24, 0x34	; 52
 218:	87 7f       	andi	r24, 0xF7	; 247
 21a:	84 bf       	out	0x34, r24	; 52

#if defined(__CODEVISIONAVR__)
#pragma optsize-
#endif
      WDTCSR |= (1<<WDCE)|(1<<WDE); // start timed sequence (keep old prescaler)
 21c:	81 b5       	in	r24, 0x21	; 33
 21e:	88 61       	ori	r24, 0x18	; 24
 220:	81 bd       	out	0x21, r24	; 33
      WDTCSR &= ~(1<<WDE); // watchdog timer off
 222:	81 b5       	in	r24, 0x21	; 33
 224:	87 7f       	andi	r24, 0xF7	; 247
 226:	81 bd       	out	0x21, r24	; 33
#if defined(__CODEVISIONAVR__) && defined(_OPTIMIZE_SIZE_)
#pragma optsize+
#endif

      sei();
 228:	78 94       	sei

      sleep_enable();
 22a:	85 b7       	in	r24, 0x35	; 53
 22c:	80 62       	ori	r24, 0x20	; 32
 22e:	85 bf       	out	0x35, r24	; 53
      sleep_cpu();
 230:	88 95       	sleep
      sleep_disable();
 232:	85 b7       	in	r24, 0x35	; 53
 234:	8f 7d       	andi	r24, 0xDF	; 223
 236:	85 bf       	out	0x35, r24	; 53

      cli();
 238:	f8 94       	cli
      wdt_reset();
 23a:	a8 95       	wdr

#if defined(__CODEVISIONAVR__)
#pragma optsize-
#endif
      WDTCSR |= (1<<WDCE)|(1<<WDE); // start timed sequence (keep old prescaler)
 23c:	81 b5       	in	r24, 0x21	; 33
 23e:	88 61       	ori	r24, 0x18	; 24
 240:	81 bd       	out	0x21, r24	; 33
      WDTCSR &= ~(1<<WDCE);
 242:	81 b5       	in	r24, 0x21	; 33
 244:	8f 7e       	andi	r24, 0xEF	; 239
 246:	81 bd       	out	0x21, r24	; 33
#if defined(__CODEVISIONAVR__) && defined(_OPTIMIZE_SIZE_)
#pragma optsize+
#endif

      sei();
 248:	78 94       	sei
 24a:	9f cf       	rjmp	.-194    	; 0x18a <main+0x96>

0000024c <__vector_13>:
#pragma interrupt_handler timer0_compa_handler:iv_TIMER0_COMPA
void timer0_compa_handler(void)
#else
  ISR(TIMER0_COMPA_vect)
#endif
{
 24c:	1f 92       	push	r1
 24e:	0f 92       	push	r0
 250:	0f b6       	in	r0, 0x3f	; 63
 252:	0f 92       	push	r0
 254:	11 24       	eor	r1, r1
 256:	8f 93       	push	r24
  sei(); // Okay to allow USART interrupts while controlling LED PWM
 258:	78 94       	sei

  // Set current LED state based on cycling variable
  if (ledPwmCycling & 0x01) {
 25a:	70 fe       	sbrs	r7, 0
 25c:	02 c0       	rjmp	.+4      	; 0x262 <__vector_13+0x16>
    LED_PORT |= (1<<LED_PIN);
 25e:	91 9a       	sbi	0x12, 1	; 18
 260:	01 c0       	rjmp	.+2      	; 0x264 <__vector_13+0x18>
  } else {
    LED_PORT &= ~(1<<LED_PIN);
 262:	91 98       	cbi	0x12, 1	; 18
  }

  // Update cycling variable for next interrupt
  if (ledPwmCount >= LED_BRIGHTNESS_LEVELS-1) {
 264:	86 e0       	ldi	r24, 0x06	; 6
 266:	84 15       	cp	r24, r4
 268:	20 f4       	brcc	.+8      	; 0x272 <__vector_13+0x26>
    ledPwmCount = 0;
 26a:	44 24       	eor	r4, r4
    ledPwmCycling = ledPwmPattern;
 26c:	83 b3       	in	r24, 0x13	; 19
 26e:	78 2e       	mov	r7, r24
 270:	02 c0       	rjmp	.+4      	; 0x276 <__vector_13+0x2a>
  } else {
    ledPwmCount++;
 272:	43 94       	inc	r4
    ledPwmCycling >>= 1;
 274:	76 94       	lsr	r7
  }
}
 276:	8f 91       	pop	r24
 278:	0f 90       	pop	r0
 27a:	0f be       	out	0x3f, r0	; 63
 27c:	0f 90       	pop	r0
 27e:	1f 90       	pop	r1
 280:	18 95       	reti

00000282 <__mulhi3>:
 282:	55 27       	eor	r21, r21
 284:	00 24       	eor	r0, r0

00000286 <__mulhi3_loop>:
 286:	80 ff       	sbrs	r24, 0
 288:	02 c0       	rjmp	.+4      	; 0x28e <__mulhi3_skip1>
 28a:	06 0e       	add	r0, r22
 28c:	57 1f       	adc	r21, r23

0000028e <__mulhi3_skip1>:
 28e:	66 0f       	add	r22, r22
 290:	77 1f       	adc	r23, r23
 292:	61 15       	cp	r22, r1
 294:	71 05       	cpc	r23, r1
 296:	21 f0       	breq	.+8      	; 0x2a0 <__mulhi3_exit>
 298:	96 95       	lsr	r25
 29a:	87 95       	ror	r24
 29c:	00 97       	sbiw	r24, 0x00	; 0
 29e:	99 f7       	brne	.-26     	; 0x286 <__mulhi3_loop>

000002a0 <__mulhi3_exit>:
 2a0:	95 2f       	mov	r25, r21
 2a2:	80 2d       	mov	r24, r0
 2a4:	08 95       	ret

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

000002a8 <__stop_program>:
 2a8:	ff cf       	rjmp	.-2      	; 0x2a8 <__stop_program>