poolclock/PoolClockHumidity/Debug/PoolClockHumidity.lss

PoolClockHumidity.elf:     file format elf32-avr

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .data         00000024  00800100  00000900  00000994  2**0
                  CONTENTS, ALLOC, LOAD, DATA
  1 .text         00000900  00000000  00000000  00000094  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  2 .bss          00000008  00800124  00800124  000009b8  2**0
                  ALLOC
  3 .comment      00000030  00000000  00000000  000009b8  2**0
                  CONTENTS, READONLY
  4 .note.gnu.avr.deviceinfo 00000040  00000000  00000000  000009e8  2**2
                  CONTENTS, READONLY
  5 .debug_aranges 00000058  00000000  00000000  00000a28  2**0
                  CONTENTS, READONLY, DEBUGGING
  6 .debug_info   0000228b  00000000  00000000  00000a80  2**0
                  CONTENTS, READONLY, DEBUGGING
  7 .debug_abbrev 00000838  00000000  00000000  00002d0b  2**0
                  CONTENTS, READONLY, DEBUGGING
  8 .debug_line   00000ba4  00000000  00000000  00003543  2**0
                  CONTENTS, READONLY, DEBUGGING
  9 .debug_frame  000000f8  00000000  00000000  000040e8  2**2
                  CONTENTS, READONLY, DEBUGGING
 10 .debug_str    000004ef  00000000  00000000  000041e0  2**0
                  CONTENTS, READONLY, DEBUGGING
 11 .debug_loc    00001e2d  00000000  00000000  000046cf  2**0
                  CONTENTS, READONLY, DEBUGGING
 12 .debug_ranges 00000168  00000000  00000000  000064fc  2**0
                  CONTENTS, READONLY, DEBUGGING

Disassembly of section .text:

00000000 <__vectors>:
   0:	19 c0       	rjmp	.+50     	; 0x34 <__ctors_end>
   2:	33 c0       	rjmp	.+102    	; 0x6a <__bad_interrupt>
   4:	32 c0       	rjmp	.+100    	; 0x6a <__bad_interrupt>
   6:	31 c0       	rjmp	.+98     	; 0x6a <__bad_interrupt>
   8:	30 c0       	rjmp	.+96     	; 0x6a <__bad_interrupt>
   a:	2f c0       	rjmp	.+94     	; 0x6a <__bad_interrupt>
   c:	2e c0       	rjmp	.+92     	; 0x6a <__bad_interrupt>
   e:	2d c0       	rjmp	.+90     	; 0x6a <__bad_interrupt>
  10:	2c c0       	rjmp	.+88     	; 0x6a <__bad_interrupt>
  12:	2b c0       	rjmp	.+86     	; 0x6a <__bad_interrupt>
  14:	2a c0       	rjmp	.+84     	; 0x6a <__bad_interrupt>
  16:	81 c0       	rjmp	.+258    	; 0x11a <__vector_11>
  18:	28 c0       	rjmp	.+80     	; 0x6a <__bad_interrupt>
  1a:	27 c0       	rjmp	.+78     	; 0x6a <__bad_interrupt>
  1c:	26 c0       	rjmp	.+76     	; 0x6a <__bad_interrupt>
  1e:	25 c0       	rjmp	.+74     	; 0x6a <__bad_interrupt>
  20:	24 c0       	rjmp	.+72     	; 0x6a <__bad_interrupt>
  22:	23 c0       	rjmp	.+70     	; 0x6a <__bad_interrupt>
  24:	22 c0       	rjmp	.+68     	; 0x6a <__bad_interrupt>
  26:	21 c0       	rjmp	.+66     	; 0x6a <__bad_interrupt>
  28:	20 c0       	rjmp	.+64     	; 0x6a <__bad_interrupt>
  2a:	1f c0       	rjmp	.+62     	; 0x6a <__bad_interrupt>
  2c:	1e c0       	rjmp	.+60     	; 0x6a <__bad_interrupt>
  2e:	1d c0       	rjmp	.+58     	; 0x6a <__bad_interrupt>
  30:	1c c0       	rjmp	.+56     	; 0x6a <__bad_interrupt>
  32:	1b c0       	rjmp	.+54     	; 0x6a <__bad_interrupt>

00000034 <__ctors_end>:
  34:	11 24       	eor	r1, r1
  36:	1f be       	out	0x3f, r1	; 63
  38:	cf ef       	ldi	r28, 0xFF	; 255
  3a:	d4 e0       	ldi	r29, 0x04	; 4
  3c:	de bf       	out	0x3e, r29	; 62
  3e:	cd bf       	out	0x3d, r28	; 61

00000040 <__do_copy_data>:
  40:	11 e0       	ldi	r17, 0x01	; 1
  42:	a0 e0       	ldi	r26, 0x00	; 0
  44:	b1 e0       	ldi	r27, 0x01	; 1
  46:	e0 e0       	ldi	r30, 0x00	; 0
  48:	f9 e0       	ldi	r31, 0x09	; 9
  4a:	02 c0       	rjmp	.+4      	; 0x50 <__do_copy_data+0x10>
  4c:	05 90       	lpm	r0, Z+
  4e:	0d 92       	st	X+, r0
  50:	a4 32       	cpi	r26, 0x24	; 36
  52:	b1 07       	cpc	r27, r17
  54:	d9 f7       	brne	.-10     	; 0x4c <__do_copy_data+0xc>

00000056 <__do_clear_bss>:
  56:	21 e0       	ldi	r18, 0x01	; 1
  58:	a4 e2       	ldi	r26, 0x24	; 36
  5a:	b1 e0       	ldi	r27, 0x01	; 1
  5c:	01 c0       	rjmp	.+2      	; 0x60 <.do_clear_bss_start>

0000005e <.do_clear_bss_loop>:
  5e:	1d 92       	st	X+, r1

00000060 <.do_clear_bss_start>:
  60:	ac 32       	cpi	r26, 0x2C	; 44
  62:	b2 07       	cpc	r27, r18
  64:	e1 f7       	brne	.-8      	; 0x5e <.do_clear_bss_loop>
  66:	1d d3       	rcall	.+1594   	; 0x6a2 <main>
  68:	49 c4       	rjmp	.+2194   	; 0x8fc <_exit>

0000006a <__bad_interrupt>:
  6a:	ca cf       	rjmp	.-108    	; 0x0 <__vectors>

0000006c <s_vInit>:
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
    g_au8Digits[DIGIT_ONES] = u8Ones;
    g_au8Digits[DIGIT_UNIT] = u8Unit;
  6c:	8f ef       	ldi	r24, 0xFF	; 255
  6e:	8a b9       	out	0x0a, r24	; 10
  70:	87 e0       	ldi	r24, 0x07	; 7
  72:	84 b9       	out	0x04, r24	; 4
  74:	80 e3       	ldi	r24, 0x30	; 48
  76:	88 b9       	out	0x08, r24	; 8
  78:	3b 98       	cbi	0x07, 3	; 7
  7a:	43 98       	cbi	0x08, 3	; 8
  7c:	10 92 80 00 	sts	0x0080, r1	; 0x800080 <__EEPROM_REGION_LENGTH__+0x7f0080>
  80:	8a e0       	ldi	r24, 0x0A	; 10
  82:	80 93 81 00 	sts	0x0081, r24	; 0x800081 <__EEPROM_REGION_LENGTH__+0x7f0081>
  86:	84 ec       	ldi	r24, 0xC4	; 196
  88:	99 e0       	ldi	r25, 0x09	; 9
  8a:	90 93 89 00 	sts	0x0089, r25	; 0x800089 <__EEPROM_REGION_LENGTH__+0x7f0089>
  8e:	80 93 88 00 	sts	0x0088, r24	; 0x800088 <__EEPROM_REGION_LENGTH__+0x7f0088>
  92:	ef e6       	ldi	r30, 0x6F	; 111
  94:	f0 e0       	ldi	r31, 0x00	; 0
  96:	80 81       	ld	r24, Z
  98:	82 60       	ori	r24, 0x02	; 2
  9a:	80 83       	st	Z, r24
  9c:	78 94       	sei
  9e:	08 95       	ret

000000a0 <s_vSetValue>:
  a0:	9d ec       	ldi	r25, 0xCD	; 205
  a2:	89 9f       	mul	r24, r25
  a4:	91 2d       	mov	r25, r1
  a6:	11 24       	eor	r1, r1
  a8:	96 95       	lsr	r25
  aa:	96 95       	lsr	r25
  ac:	96 95       	lsr	r25
  ae:	e0 e0       	ldi	r30, 0x00	; 0
  b0:	f1 e0       	ldi	r31, 0x01	; 1
  b2:	92 83       	std	Z+2, r25	; 0x02
  b4:	99 0f       	add	r25, r25
  b6:	29 2f       	mov	r18, r25
  b8:	22 0f       	add	r18, r18
  ba:	22 0f       	add	r18, r18
  bc:	92 0f       	add	r25, r18
  be:	89 1b       	sub	r24, r25
  c0:	81 83       	std	Z+1, r24	; 0x01
  c2:	60 83       	st	Z, r22
  c4:	08 95       	ret

000000c6 <s_vReadButtons>:
/************************************************************************/
/* Read button status                                                   */
/************************************************************************/
void s_vReadButtons( void )
{
    if ( !(PINC & (1<<PINC4)) ) //if button '+' pressed
  c6:	34 99       	sbic	0x06, 4	; 6
  c8:	06 c0       	rjmp	.+12     	; 0xd6 <s_vReadButtons+0x10>
    {
        g_u8ButtonCountTop++;
  ca:	80 91 2b 01 	lds	r24, 0x012B	; 0x80012b <g_u8ButtonCountTop>
  ce:	8f 5f       	subi	r24, 0xFF	; 255
  d0:	80 93 2b 01 	sts	0x012B, r24	; 0x80012b <g_u8ButtonCountTop>
  d4:	02 c0       	rjmp	.+4      	; 0xda <s_vReadButtons+0x14>
    }
    else
    {
        g_u8ButtonCountTop = 0U; //reset button counter
  d6:	10 92 2b 01 	sts	0x012B, r1	; 0x80012b <g_u8ButtonCountTop>
    }
    
    if ( !(PINC & (1<<PINC5)) ) //if button '-' pressed
  da:	35 99       	sbic	0x06, 5	; 6
  dc:	0a c0       	rjmp	.+20     	; 0xf2 <s_vReadButtons+0x2c>
    {
        g_u8ButtonCountBot++;
  de:	80 91 2a 01 	lds	r24, 0x012A	; 0x80012a <g_u8ButtonCountBot>
  e2:	8f 5f       	subi	r24, 0xFF	; 255
  e4:	80 93 2a 01 	sts	0x012A, r24	; 0x80012a <g_u8ButtonCountBot>
    else
    {
        g_u8ButtonCountBot = 0U; //reset button counter
    }
    
    if ( g_u8ButtonCountTop > BUTTON_THRESHOLD )
  e8:	90 91 2b 01 	lds	r25, 0x012B	; 0x80012b <g_u8ButtonCountTop>
  ec:	93 33       	cpi	r25, 0x33	; 51
  ee:	68 f0       	brcs	.+26     	; 0x10a <s_vReadButtons+0x44>
  f0:	06 c0       	rjmp	.+12     	; 0xfe <s_vReadButtons+0x38>
    {
        g_u8ButtonCountBot++;
    }
    else
    {
        g_u8ButtonCountBot = 0U; //reset button counter
  f2:	10 92 2a 01 	sts	0x012A, r1	; 0x80012a <g_u8ButtonCountBot>
    }
    
    if ( g_u8ButtonCountTop > BUTTON_THRESHOLD )
  f6:	80 91 2b 01 	lds	r24, 0x012B	; 0x80012b <g_u8ButtonCountTop>
  fa:	83 33       	cpi	r24, 0x33	; 51
  fc:	68 f0       	brcs	.+26     	; 0x118 <s_vReadButtons+0x52>
    {
        g_u8ButtonCountTop = 0U; //reset top counter
  fe:	10 92 2b 01 	sts	0x012B, r1	; 0x80012b <g_u8ButtonCountTop>
        g_u8Mode =  MODE_ANIMATION_1;
 102:	81 e0       	ldi	r24, 0x01	; 1
 104:	80 93 29 01 	sts	0x0129, r24	; 0x800129 <g_u8Mode>
 108:	08 95       	ret
    }
    else if ( g_u8ButtonCountBot > BUTTON_THRESHOLD )
 10a:	83 33       	cpi	r24, 0x33	; 51
 10c:	28 f0       	brcs	.+10     	; 0x118 <s_vReadButtons+0x52>
    {
        g_u8ButtonCountBot = 0U; //reset bottom counter
 10e:	10 92 2a 01 	sts	0x012A, r1	; 0x80012a <g_u8ButtonCountBot>
        g_u8Mode =  MODE_ANIMATION_2;
 112:	82 e0       	ldi	r24, 0x02	; 2
 114:	80 93 29 01 	sts	0x0129, r24	; 0x800129 <g_u8Mode>
 118:	08 95       	ret

0000011a <__vector_11>:

/************************************************************************/
/* Timer1 ISR - show values on display                                  */
/************************************************************************/
ISR ( TIMER1_COMPA_vect )
{
 11a:	1f 92       	push	r1
 11c:	0f 92       	push	r0
 11e:	0f b6       	in	r0, 0x3f	; 63
 120:	0f 92       	push	r0
 122:	11 24       	eor	r1, r1
 124:	2f 93       	push	r18
 126:	3f 93       	push	r19
 128:	4f 93       	push	r20
 12a:	5f 93       	push	r21
 12c:	6f 93       	push	r22
 12e:	7f 93       	push	r23
 130:	8f 93       	push	r24
 132:	9f 93       	push	r25
 134:	af 93       	push	r26
 136:	bf 93       	push	r27
 138:	ef 93       	push	r30
 13a:	ff 93       	push	r31
    PORTB = 0;
 13c:	15 b8       	out	0x05, r1	; 5
    PORTD = 0;
 13e:	1b b8       	out	0x0b, r1	; 11
	#else
		//round up by default
		__ticks_dc = (uint32_t)(ceil(fabs(__tmp)));
	#endif

	__builtin_avr_delay_cycles(__ticks_dc);
 140:	8d e0       	ldi	r24, 0x0D	; 13
 142:	8a 95       	dec	r24
 144:	f1 f7       	brne	.-4      	; 0x142 <__vector_11+0x28>
 146:	00 00       	nop
    _delay_us(2);
    PORTB = SELECT_DIGIT(g_u8ISRDigitSelect);
 148:	81 e0       	ldi	r24, 0x01	; 1
 14a:	90 e0       	ldi	r25, 0x00	; 0
 14c:	00 90 24 01 	lds	r0, 0x0124	; 0x800124 <__data_end>
 150:	02 c0       	rjmp	.+4      	; 0x156 <__vector_11+0x3c>
 152:	88 0f       	add	r24, r24
 154:	99 1f       	adc	r25, r25
 156:	0a 94       	dec	r0
 158:	e2 f7       	brpl	.-8      	; 0x152 <__vector_11+0x38>
 15a:	85 b9       	out	0x05, r24	; 5
    PORTD = g_au8Symbols[g_au8Digits[g_u8ISRDigitSelect]];
 15c:	e0 91 24 01 	lds	r30, 0x0124	; 0x800124 <__data_end>
 160:	f0 e0       	ldi	r31, 0x00	; 0
 162:	e0 50       	subi	r30, 0x00	; 0
 164:	ff 4f       	sbci	r31, 0xFF	; 255
 166:	e0 81       	ld	r30, Z
 168:	f0 e0       	ldi	r31, 0x00	; 0
 16a:	ed 5f       	subi	r30, 0xFD	; 253
 16c:	fe 4f       	sbci	r31, 0xFE	; 254
 16e:	80 81       	ld	r24, Z
 170:	8b b9       	out	0x0b, r24	; 11
    g_u8ISRDigitSelect++;
 172:	80 91 24 01 	lds	r24, 0x0124	; 0x800124 <__data_end>
 176:	8f 5f       	subi	r24, 0xFF	; 255
    if (g_u8ISRDigitSelect > 2U)
 178:	83 30       	cpi	r24, 0x03	; 3
 17a:	18 f4       	brcc	.+6      	; 0x182 <__vector_11+0x68>
    PORTB = 0;
    PORTD = 0;
    _delay_us(2);
    PORTB = SELECT_DIGIT(g_u8ISRDigitSelect);
    PORTD = g_au8Symbols[g_au8Digits[g_u8ISRDigitSelect]];
    g_u8ISRDigitSelect++;
 17c:	80 93 24 01 	sts	0x0124, r24	; 0x800124 <__data_end>
 180:	02 c0       	rjmp	.+4      	; 0x186 <__vector_11+0x6c>
    if (g_u8ISRDigitSelect > 2U)
    {
        g_u8ISRDigitSelect = 0U;
 182:	10 92 24 01 	sts	0x0124, r1	; 0x800124 <__data_end>
    }
    
    /* Read and evaluate button status */
    s_vReadButtons();
 186:	9f df       	rcall	.-194    	; 0xc6 <s_vReadButtons>
}
 188:	ff 91       	pop	r31
 18a:	ef 91       	pop	r30
 18c:	bf 91       	pop	r27
 18e:	af 91       	pop	r26
 190:	9f 91       	pop	r25
 192:	8f 91       	pop	r24
 194:	7f 91       	pop	r23
 196:	6f 91       	pop	r22
 198:	5f 91       	pop	r21
 19a:	4f 91       	pop	r20
 19c:	3f 91       	pop	r19
 19e:	2f 91       	pop	r18
 1a0:	0f 90       	pop	r0
 1a2:	0f be       	out	0x3f, r0	; 63
 1a4:	0f 90       	pop	r0
 1a6:	1f 90       	pop	r1
 1a8:	18 95       	reti

000001aa <s_vShowAnim>:
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 1aa:	e0 e0       	ldi	r30, 0x00	; 0
 1ac:	f1 e0       	ldi	r31, 0x01	; 1
 1ae:	90 e1       	ldi	r25, 0x10	; 16
 1b0:	92 83       	std	Z+2, r25	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 1b2:	91 83       	std	Z+1, r25	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 1b4:	90 83       	st	Z, r25
	#else
		//round up by default
		__ticks_dc = (uint32_t)(ceil(fabs(__tmp)));
	#endif

	__builtin_avr_delay_cycles(__ticks_dc);
 1b6:	2f eb       	ldi	r18, 0xBF	; 191
 1b8:	35 e4       	ldi	r19, 0x45	; 69
 1ba:	44 e0       	ldi	r20, 0x04	; 4
 1bc:	21 50       	subi	r18, 0x01	; 1
 1be:	30 40       	sbci	r19, 0x00	; 0
 1c0:	40 40       	sbci	r20, 0x00	; 0
 1c2:	e1 f7       	brne	.-8      	; 0x1bc <s_vShowAnim+0x12>
 1c4:	00 c0       	rjmp	.+0      	; 0x1c6 <s_vShowAnim+0x1c>
 1c6:	00 00       	nop
/************************************************************************/
void s_vShowAnim( uint8_t u8Select )
{
    s_vSetDisplayDigits( SYM_OFF, SYM_OFF, SYM_OFF );
    _delay_ms(ANIMATION_DELAY_MS);
    switch ( u8Select )
 1c8:	81 30       	cpi	r24, 0x01	; 1
 1ca:	21 f0       	breq	.+8      	; 0x1d4 <s_vShowAnim+0x2a>
 1cc:	82 30       	cpi	r24, 0x02	; 2
 1ce:	09 f4       	brne	.+2      	; 0x1d2 <s_vShowAnim+0x28>
 1d0:	e2 c0       	rjmp	.+452    	; 0x396 <s_vShowAnim+0x1ec>
 1d2:	c1 c1       	rjmp	.+898    	; 0x556 <__stack+0x57>
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 1d4:	e0 e0       	ldi	r30, 0x00	; 0
 1d6:	f1 e0       	ldi	r31, 0x01	; 1
 1d8:	22 e1       	ldi	r18, 0x12	; 18
 1da:	22 83       	std	Z+2, r18	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 1dc:	90 e1       	ldi	r25, 0x10	; 16
 1de:	91 83       	std	Z+1, r25	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 1e0:	90 83       	st	Z, r25
 1e2:	5f eb       	ldi	r21, 0xBF	; 191
 1e4:	65 e4       	ldi	r22, 0x45	; 69
 1e6:	74 e0       	ldi	r23, 0x04	; 4
 1e8:	51 50       	subi	r21, 0x01	; 1
 1ea:	60 40       	sbci	r22, 0x00	; 0
 1ec:	70 40       	sbci	r23, 0x00	; 0
 1ee:	e1 f7       	brne	.-8      	; 0x1e8 <s_vShowAnim+0x3e>
 1f0:	00 c0       	rjmp	.+0      	; 0x1f2 <s_vShowAnim+0x48>
 1f2:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 1f4:	3c e0       	ldi	r19, 0x0C	; 12
 1f6:	32 83       	std	Z+2, r19	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 1f8:	91 83       	std	Z+1, r25	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 1fa:	90 83       	st	Z, r25
 1fc:	8f eb       	ldi	r24, 0xBF	; 191
 1fe:	a5 e4       	ldi	r26, 0x45	; 69
 200:	44 e0       	ldi	r20, 0x04	; 4
 202:	81 50       	subi	r24, 0x01	; 1
 204:	a0 40       	sbci	r26, 0x00	; 0
 206:	40 40       	sbci	r20, 0x00	; 0
 208:	e1 f7       	brne	.-8      	; 0x202 <s_vShowAnim+0x58>
 20a:	00 c0       	rjmp	.+0      	; 0x20c <s_vShowAnim+0x62>
 20c:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 20e:	88 e0       	ldi	r24, 0x08	; 8
 210:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 212:	91 83       	std	Z+1, r25	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 214:	90 83       	st	Z, r25
 216:	5f eb       	ldi	r21, 0xBF	; 191
 218:	65 e4       	ldi	r22, 0x45	; 69
 21a:	74 e0       	ldi	r23, 0x04	; 4
 21c:	51 50       	subi	r21, 0x01	; 1
 21e:	60 40       	sbci	r22, 0x00	; 0
 220:	70 40       	sbci	r23, 0x00	; 0
 222:	e1 f7       	brne	.-8      	; 0x21c <s_vShowAnim+0x72>
 224:	00 c0       	rjmp	.+0      	; 0x226 <s_vShowAnim+0x7c>
 226:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 228:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 22a:	21 83       	std	Z+1, r18	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 22c:	90 83       	st	Z, r25
 22e:	af eb       	ldi	r26, 0xBF	; 191
 230:	45 e4       	ldi	r20, 0x45	; 69
 232:	54 e0       	ldi	r21, 0x04	; 4
 234:	a1 50       	subi	r26, 0x01	; 1
 236:	40 40       	sbci	r20, 0x00	; 0
 238:	50 40       	sbci	r21, 0x00	; 0
 23a:	e1 f7       	brne	.-8      	; 0x234 <s_vShowAnim+0x8a>
 23c:	00 c0       	rjmp	.+0      	; 0x23e <s_vShowAnim+0x94>
 23e:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 240:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 242:	31 83       	std	Z+1, r19	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 244:	90 83       	st	Z, r25
 246:	6f eb       	ldi	r22, 0xBF	; 191
 248:	75 e4       	ldi	r23, 0x45	; 69
 24a:	a4 e0       	ldi	r26, 0x04	; 4
 24c:	61 50       	subi	r22, 0x01	; 1
 24e:	70 40       	sbci	r23, 0x00	; 0
 250:	a0 40       	sbci	r26, 0x00	; 0
 252:	e1 f7       	brne	.-8      	; 0x24c <s_vShowAnim+0xa2>
 254:	00 c0       	rjmp	.+0      	; 0x256 <s_vShowAnim+0xac>
 256:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 258:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 25a:	81 83       	std	Z+1, r24	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 25c:	90 83       	st	Z, r25
 25e:	4f eb       	ldi	r20, 0xBF	; 191
 260:	55 e4       	ldi	r21, 0x45	; 69
 262:	64 e0       	ldi	r22, 0x04	; 4
 264:	41 50       	subi	r20, 0x01	; 1
 266:	50 40       	sbci	r21, 0x00	; 0
 268:	60 40       	sbci	r22, 0x00	; 0
 26a:	e1 f7       	brne	.-8      	; 0x264 <s_vShowAnim+0xba>
 26c:	00 c0       	rjmp	.+0      	; 0x26e <s_vShowAnim+0xc4>
 26e:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 270:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 272:	81 83       	std	Z+1, r24	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 274:	41 e0       	ldi	r20, 0x01	; 1
 276:	40 83       	st	Z, r20
 278:	7f eb       	ldi	r23, 0xBF	; 191
 27a:	a5 e4       	ldi	r26, 0x45	; 69
 27c:	54 e0       	ldi	r21, 0x04	; 4
 27e:	71 50       	subi	r23, 0x01	; 1
 280:	a0 40       	sbci	r26, 0x00	; 0
 282:	50 40       	sbci	r21, 0x00	; 0
 284:	e1 f7       	brne	.-8      	; 0x27e <s_vShowAnim+0xd4>
 286:	00 c0       	rjmp	.+0      	; 0x288 <s_vShowAnim+0xde>
 288:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 28a:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 28c:	81 83       	std	Z+1, r24	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 28e:	53 e0       	ldi	r21, 0x03	; 3
 290:	50 83       	st	Z, r21
 292:	6f eb       	ldi	r22, 0xBF	; 191
 294:	75 e4       	ldi	r23, 0x45	; 69
 296:	a4 e0       	ldi	r26, 0x04	; 4
 298:	61 50       	subi	r22, 0x01	; 1
 29a:	70 40       	sbci	r23, 0x00	; 0
 29c:	a0 40       	sbci	r26, 0x00	; 0
 29e:	e1 f7       	brne	.-8      	; 0x298 <s_vShowAnim+0xee>
 2a0:	00 c0       	rjmp	.+0      	; 0x2a2 <s_vShowAnim+0xf8>
 2a2:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 2a4:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 2a6:	81 83       	std	Z+1, r24	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 2a8:	80 83       	st	Z, r24
 2aa:	6f eb       	ldi	r22, 0xBF	; 191
 2ac:	75 e4       	ldi	r23, 0x45	; 69
 2ae:	a4 e0       	ldi	r26, 0x04	; 4
 2b0:	61 50       	subi	r22, 0x01	; 1
 2b2:	70 40       	sbci	r23, 0x00	; 0
 2b4:	a0 40       	sbci	r26, 0x00	; 0
 2b6:	e1 f7       	brne	.-8      	; 0x2b0 <s_vShowAnim+0x106>
 2b8:	00 c0       	rjmp	.+0      	; 0x2ba <s_vShowAnim+0x110>
 2ba:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 2bc:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 2be:	81 83       	std	Z+1, r24	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 2c0:	80 83       	st	Z, r24
 2c2:	6f eb       	ldi	r22, 0xBF	; 191
 2c4:	75 e4       	ldi	r23, 0x45	; 69
 2c6:	a4 e0       	ldi	r26, 0x04	; 4
 2c8:	61 50       	subi	r22, 0x01	; 1
 2ca:	70 40       	sbci	r23, 0x00	; 0
 2cc:	a0 40       	sbci	r26, 0x00	; 0
 2ce:	e1 f7       	brne	.-8      	; 0x2c8 <s_vShowAnim+0x11e>
 2d0:	00 c0       	rjmp	.+0      	; 0x2d2 <s_vShowAnim+0x128>
 2d2:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 2d4:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 2d6:	81 83       	std	Z+1, r24	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 2d8:	50 83       	st	Z, r21
 2da:	5f eb       	ldi	r21, 0xBF	; 191
 2dc:	65 e4       	ldi	r22, 0x45	; 69
 2de:	74 e0       	ldi	r23, 0x04	; 4
 2e0:	51 50       	subi	r21, 0x01	; 1
 2e2:	60 40       	sbci	r22, 0x00	; 0
 2e4:	70 40       	sbci	r23, 0x00	; 0
 2e6:	e1 f7       	brne	.-8      	; 0x2e0 <s_vShowAnim+0x136>
 2e8:	00 c0       	rjmp	.+0      	; 0x2ea <s_vShowAnim+0x140>
 2ea:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 2ec:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 2ee:	81 83       	std	Z+1, r24	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 2f0:	40 83       	st	Z, r20
 2f2:	af eb       	ldi	r26, 0xBF	; 191
 2f4:	45 e4       	ldi	r20, 0x45	; 69
 2f6:	54 e0       	ldi	r21, 0x04	; 4
 2f8:	a1 50       	subi	r26, 0x01	; 1
 2fa:	40 40       	sbci	r20, 0x00	; 0
 2fc:	50 40       	sbci	r21, 0x00	; 0
 2fe:	e1 f7       	brne	.-8      	; 0x2f8 <s_vShowAnim+0x14e>
 300:	00 c0       	rjmp	.+0      	; 0x302 <s_vShowAnim+0x158>
 302:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 304:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 306:	81 83       	std	Z+1, r24	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 308:	90 83       	st	Z, r25
 30a:	6f eb       	ldi	r22, 0xBF	; 191
 30c:	75 e4       	ldi	r23, 0x45	; 69
 30e:	a4 e0       	ldi	r26, 0x04	; 4
 310:	61 50       	subi	r22, 0x01	; 1
 312:	70 40       	sbci	r23, 0x00	; 0
 314:	a0 40       	sbci	r26, 0x00	; 0
 316:	e1 f7       	brne	.-8      	; 0x310 <s_vShowAnim+0x166>
 318:	00 c0       	rjmp	.+0      	; 0x31a <s_vShowAnim+0x170>
 31a:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 31c:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 31e:	31 83       	std	Z+1, r19	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 320:	90 83       	st	Z, r25
 322:	4f eb       	ldi	r20, 0xBF	; 191
 324:	55 e4       	ldi	r21, 0x45	; 69
 326:	64 e0       	ldi	r22, 0x04	; 4
 328:	41 50       	subi	r20, 0x01	; 1
 32a:	50 40       	sbci	r21, 0x00	; 0
 32c:	60 40       	sbci	r22, 0x00	; 0
 32e:	e1 f7       	brne	.-8      	; 0x328 <s_vShowAnim+0x17e>
 330:	00 c0       	rjmp	.+0      	; 0x332 <s_vShowAnim+0x188>
 332:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 334:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 336:	21 83       	std	Z+1, r18	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 338:	90 83       	st	Z, r25
 33a:	7f eb       	ldi	r23, 0xBF	; 191
 33c:	a5 e4       	ldi	r26, 0x45	; 69
 33e:	44 e0       	ldi	r20, 0x04	; 4
 340:	71 50       	subi	r23, 0x01	; 1
 342:	a0 40       	sbci	r26, 0x00	; 0
 344:	40 40       	sbci	r20, 0x00	; 0
 346:	e1 f7       	brne	.-8      	; 0x340 <s_vShowAnim+0x196>
 348:	00 c0       	rjmp	.+0      	; 0x34a <s_vShowAnim+0x1a0>
 34a:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 34c:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 34e:	91 83       	std	Z+1, r25	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 350:	90 83       	st	Z, r25
 352:	5f eb       	ldi	r21, 0xBF	; 191
 354:	65 e4       	ldi	r22, 0x45	; 69
 356:	74 e0       	ldi	r23, 0x04	; 4
 358:	51 50       	subi	r21, 0x01	; 1
 35a:	60 40       	sbci	r22, 0x00	; 0
 35c:	70 40       	sbci	r23, 0x00	; 0
 35e:	e1 f7       	brne	.-8      	; 0x358 <s_vShowAnim+0x1ae>
 360:	00 c0       	rjmp	.+0      	; 0x362 <s_vShowAnim+0x1b8>
 362:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 364:	32 83       	std	Z+2, r19	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 366:	91 83       	std	Z+1, r25	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 368:	90 83       	st	Z, r25
 36a:	8f eb       	ldi	r24, 0xBF	; 191
 36c:	a5 e4       	ldi	r26, 0x45	; 69
 36e:	34 e0       	ldi	r19, 0x04	; 4
 370:	81 50       	subi	r24, 0x01	; 1
 372:	a0 40       	sbci	r26, 0x00	; 0
 374:	30 40       	sbci	r19, 0x00	; 0
 376:	e1 f7       	brne	.-8      	; 0x370 <s_vShowAnim+0x1c6>
 378:	00 c0       	rjmp	.+0      	; 0x37a <s_vShowAnim+0x1d0>
 37a:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 37c:	22 83       	std	Z+2, r18	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 37e:	91 83       	std	Z+1, r25	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 380:	90 83       	st	Z, r25
 382:	4f eb       	ldi	r20, 0xBF	; 191
 384:	55 e4       	ldi	r21, 0x45	; 69
 386:	64 e0       	ldi	r22, 0x04	; 4
 388:	41 50       	subi	r20, 0x01	; 1
 38a:	50 40       	sbci	r21, 0x00	; 0
 38c:	60 40       	sbci	r22, 0x00	; 0
 38e:	e1 f7       	brne	.-8      	; 0x388 <s_vShowAnim+0x1de>
 390:	00 c0       	rjmp	.+0      	; 0x392 <s_vShowAnim+0x1e8>
 392:	00 00       	nop
 394:	e0 c0       	rjmp	.+448    	; 0x556 <__stack+0x57>
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 396:	e0 e0       	ldi	r30, 0x00	; 0
 398:	f1 e0       	ldi	r31, 0x01	; 1
 39a:	22 e1       	ldi	r18, 0x12	; 18
 39c:	22 83       	std	Z+2, r18	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 39e:	80 e1       	ldi	r24, 0x10	; 16
 3a0:	81 83       	std	Z+1, r24	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 3a2:	80 83       	st	Z, r24
 3a4:	7f eb       	ldi	r23, 0xBF	; 191
 3a6:	95 e4       	ldi	r25, 0x45	; 69
 3a8:	a4 e0       	ldi	r26, 0x04	; 4
 3aa:	71 50       	subi	r23, 0x01	; 1
 3ac:	90 40       	sbci	r25, 0x00	; 0
 3ae:	a0 40       	sbci	r26, 0x00	; 0
 3b0:	e1 f7       	brne	.-8      	; 0x3aa <s_vShowAnim+0x200>
 3b2:	00 c0       	rjmp	.+0      	; 0x3b4 <s_vShowAnim+0x20a>
 3b4:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 3b6:	3c e0       	ldi	r19, 0x0C	; 12
 3b8:	32 83       	std	Z+2, r19	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 3ba:	81 83       	std	Z+1, r24	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 3bc:	80 83       	st	Z, r24
 3be:	4f eb       	ldi	r20, 0xBF	; 191
 3c0:	55 e4       	ldi	r21, 0x45	; 69
 3c2:	64 e0       	ldi	r22, 0x04	; 4
 3c4:	41 50       	subi	r20, 0x01	; 1
 3c6:	50 40       	sbci	r21, 0x00	; 0
 3c8:	60 40       	sbci	r22, 0x00	; 0
 3ca:	e1 f7       	brne	.-8      	; 0x3c4 <s_vShowAnim+0x21a>
 3cc:	00 c0       	rjmp	.+0      	; 0x3ce <s_vShowAnim+0x224>
 3ce:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 3d0:	98 e0       	ldi	r25, 0x08	; 8
 3d2:	92 83       	std	Z+2, r25	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 3d4:	81 83       	std	Z+1, r24	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 3d6:	80 83       	st	Z, r24
 3d8:	7f eb       	ldi	r23, 0xBF	; 191
 3da:	a5 e4       	ldi	r26, 0x45	; 69
 3dc:	44 e0       	ldi	r20, 0x04	; 4
 3de:	71 50       	subi	r23, 0x01	; 1
 3e0:	a0 40       	sbci	r26, 0x00	; 0
 3e2:	40 40       	sbci	r20, 0x00	; 0
 3e4:	e1 f7       	brne	.-8      	; 0x3de <s_vShowAnim+0x234>
 3e6:	00 c0       	rjmp	.+0      	; 0x3e8 <s_vShowAnim+0x23e>
 3e8:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 3ea:	92 83       	std	Z+2, r25	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 3ec:	21 83       	std	Z+1, r18	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 3ee:	80 83       	st	Z, r24
 3f0:	5f eb       	ldi	r21, 0xBF	; 191
 3f2:	65 e4       	ldi	r22, 0x45	; 69
 3f4:	74 e0       	ldi	r23, 0x04	; 4
 3f6:	51 50       	subi	r21, 0x01	; 1
 3f8:	60 40       	sbci	r22, 0x00	; 0
 3fa:	70 40       	sbci	r23, 0x00	; 0
 3fc:	e1 f7       	brne	.-8      	; 0x3f6 <s_vShowAnim+0x24c>
 3fe:	00 c0       	rjmp	.+0      	; 0x400 <__LOCK_REGION_LENGTH__>
 400:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 402:	92 83       	std	Z+2, r25	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 404:	31 83       	std	Z+1, r19	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 406:	80 83       	st	Z, r24
 408:	af eb       	ldi	r26, 0xBF	; 191
 40a:	45 e4       	ldi	r20, 0x45	; 69
 40c:	54 e0       	ldi	r21, 0x04	; 4
 40e:	a1 50       	subi	r26, 0x01	; 1
 410:	40 40       	sbci	r20, 0x00	; 0
 412:	50 40       	sbci	r21, 0x00	; 0
 414:	e1 f7       	brne	.-8      	; 0x40e <__LOCK_REGION_LENGTH__+0xe>
 416:	00 c0       	rjmp	.+0      	; 0x418 <__LOCK_REGION_LENGTH__+0x18>
 418:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 41a:	92 83       	std	Z+2, r25	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 41c:	91 83       	std	Z+1, r25	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 41e:	80 83       	st	Z, r24
 420:	6f eb       	ldi	r22, 0xBF	; 191
 422:	75 e4       	ldi	r23, 0x45	; 69
 424:	a4 e0       	ldi	r26, 0x04	; 4
 426:	61 50       	subi	r22, 0x01	; 1
 428:	70 40       	sbci	r23, 0x00	; 0
 42a:	a0 40       	sbci	r26, 0x00	; 0
 42c:	e1 f7       	brne	.-8      	; 0x426 <__LOCK_REGION_LENGTH__+0x26>
 42e:	00 c0       	rjmp	.+0      	; 0x430 <__LOCK_REGION_LENGTH__+0x30>
 430:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 432:	92 83       	std	Z+2, r25	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 434:	91 83       	std	Z+1, r25	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 436:	41 e0       	ldi	r20, 0x01	; 1
 438:	40 83       	st	Z, r20
 43a:	5f eb       	ldi	r21, 0xBF	; 191
 43c:	65 e4       	ldi	r22, 0x45	; 69
 43e:	74 e0       	ldi	r23, 0x04	; 4
 440:	51 50       	subi	r21, 0x01	; 1
 442:	60 40       	sbci	r22, 0x00	; 0
 444:	70 40       	sbci	r23, 0x00	; 0
 446:	e1 f7       	brne	.-8      	; 0x440 <__LOCK_REGION_LENGTH__+0x40>
 448:	00 c0       	rjmp	.+0      	; 0x44a <__LOCK_REGION_LENGTH__+0x4a>
 44a:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 44c:	92 83       	std	Z+2, r25	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 44e:	91 83       	std	Z+1, r25	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 450:	53 e0       	ldi	r21, 0x03	; 3
 452:	50 83       	st	Z, r21
 454:	af eb       	ldi	r26, 0xBF	; 191
 456:	65 e4       	ldi	r22, 0x45	; 69
 458:	74 e0       	ldi	r23, 0x04	; 4
 45a:	a1 50       	subi	r26, 0x01	; 1
 45c:	60 40       	sbci	r22, 0x00	; 0
 45e:	70 40       	sbci	r23, 0x00	; 0
 460:	e1 f7       	brne	.-8      	; 0x45a <__LOCK_REGION_LENGTH__+0x5a>
 462:	00 c0       	rjmp	.+0      	; 0x464 <__LOCK_REGION_LENGTH__+0x64>
 464:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 466:	92 83       	std	Z+2, r25	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 468:	91 83       	std	Z+1, r25	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 46a:	90 83       	st	Z, r25
 46c:	af eb       	ldi	r26, 0xBF	; 191
 46e:	65 e4       	ldi	r22, 0x45	; 69
 470:	74 e0       	ldi	r23, 0x04	; 4
 472:	a1 50       	subi	r26, 0x01	; 1
 474:	60 40       	sbci	r22, 0x00	; 0
 476:	70 40       	sbci	r23, 0x00	; 0
 478:	e1 f7       	brne	.-8      	; 0x472 <__LOCK_REGION_LENGTH__+0x72>
 47a:	00 c0       	rjmp	.+0      	; 0x47c <__LOCK_REGION_LENGTH__+0x7c>
 47c:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 47e:	52 83       	std	Z+2, r21	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 480:	91 83       	std	Z+1, r25	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 482:	90 83       	st	Z, r25
 484:	af eb       	ldi	r26, 0xBF	; 191
 486:	65 e4       	ldi	r22, 0x45	; 69
 488:	74 e0       	ldi	r23, 0x04	; 4
 48a:	a1 50       	subi	r26, 0x01	; 1
 48c:	60 40       	sbci	r22, 0x00	; 0
 48e:	70 40       	sbci	r23, 0x00	; 0
 490:	e1 f7       	brne	.-8      	; 0x48a <__LOCK_REGION_LENGTH__+0x8a>
 492:	00 c0       	rjmp	.+0      	; 0x494 <__LOCK_REGION_LENGTH__+0x94>
 494:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 496:	42 83       	std	Z+2, r20	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 498:	91 83       	std	Z+1, r25	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 49a:	90 83       	st	Z, r25
 49c:	af eb       	ldi	r26, 0xBF	; 191
 49e:	65 e4       	ldi	r22, 0x45	; 69
 4a0:	74 e0       	ldi	r23, 0x04	; 4
 4a2:	a1 50       	subi	r26, 0x01	; 1
 4a4:	60 40       	sbci	r22, 0x00	; 0
 4a6:	70 40       	sbci	r23, 0x00	; 0
 4a8:	e1 f7       	brne	.-8      	; 0x4a2 <__LOCK_REGION_LENGTH__+0xa2>
 4aa:	00 c0       	rjmp	.+0      	; 0x4ac <__LOCK_REGION_LENGTH__+0xac>
 4ac:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 4ae:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 4b0:	91 83       	std	Z+1, r25	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 4b2:	90 83       	st	Z, r25
 4b4:	af eb       	ldi	r26, 0xBF	; 191
 4b6:	65 e4       	ldi	r22, 0x45	; 69
 4b8:	74 e0       	ldi	r23, 0x04	; 4
 4ba:	a1 50       	subi	r26, 0x01	; 1
 4bc:	60 40       	sbci	r22, 0x00	; 0
 4be:	70 40       	sbci	r23, 0x00	; 0
 4c0:	e1 f7       	brne	.-8      	; 0x4ba <__LOCK_REGION_LENGTH__+0xba>
 4c2:	00 c0       	rjmp	.+0      	; 0x4c4 <__LOCK_REGION_LENGTH__+0xc4>
 4c4:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 4c6:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 4c8:	51 83       	std	Z+1, r21	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 4ca:	90 83       	st	Z, r25
 4cc:	af eb       	ldi	r26, 0xBF	; 191
 4ce:	55 e4       	ldi	r21, 0x45	; 69
 4d0:	64 e0       	ldi	r22, 0x04	; 4
 4d2:	a1 50       	subi	r26, 0x01	; 1
 4d4:	50 40       	sbci	r21, 0x00	; 0
 4d6:	60 40       	sbci	r22, 0x00	; 0
 4d8:	e1 f7       	brne	.-8      	; 0x4d2 <__LOCK_REGION_LENGTH__+0xd2>
 4da:	00 c0       	rjmp	.+0      	; 0x4dc <__LOCK_REGION_LENGTH__+0xdc>
 4dc:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 4de:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 4e0:	41 83       	std	Z+1, r20	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 4e2:	90 83       	st	Z, r25
 4e4:	7f eb       	ldi	r23, 0xBF	; 191
 4e6:	a5 e4       	ldi	r26, 0x45	; 69
 4e8:	44 e0       	ldi	r20, 0x04	; 4
 4ea:	71 50       	subi	r23, 0x01	; 1
 4ec:	a0 40       	sbci	r26, 0x00	; 0
 4ee:	40 40       	sbci	r20, 0x00	; 0
 4f0:	e1 f7       	brne	.-8      	; 0x4ea <__LOCK_REGION_LENGTH__+0xea>
 4f2:	00 c0       	rjmp	.+0      	; 0x4f4 <__LOCK_REGION_LENGTH__+0xf4>
 4f4:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 4f6:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 4f8:	81 83       	std	Z+1, r24	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 4fa:	90 83       	st	Z, r25
 4fc:	5f eb       	ldi	r21, 0xBF	; 191
 4fe:	65 e4       	ldi	r22, 0x45	; 69
 500:	74 e0       	ldi	r23, 0x04	; 4
 502:	51 50       	subi	r21, 0x01	; 1
 504:	60 40       	sbci	r22, 0x00	; 0
 506:	70 40       	sbci	r23, 0x00	; 0
 508:	e1 f7       	brne	.-8      	; 0x502 <__stack+0x3>
 50a:	00 c0       	rjmp	.+0      	; 0x50c <__stack+0xd>
 50c:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 50e:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 510:	81 83       	std	Z+1, r24	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 512:	30 83       	st	Z, r19
 514:	9f eb       	ldi	r25, 0xBF	; 191
 516:	a5 e4       	ldi	r26, 0x45	; 69
 518:	34 e0       	ldi	r19, 0x04	; 4
 51a:	91 50       	subi	r25, 0x01	; 1
 51c:	a0 40       	sbci	r26, 0x00	; 0
 51e:	30 40       	sbci	r19, 0x00	; 0
 520:	e1 f7       	brne	.-8      	; 0x51a <__stack+0x1b>
 522:	00 c0       	rjmp	.+0      	; 0x524 <__stack+0x25>
 524:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 526:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 528:	81 83       	std	Z+1, r24	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 52a:	20 83       	st	Z, r18
 52c:	4f eb       	ldi	r20, 0xBF	; 191
 52e:	55 e4       	ldi	r21, 0x45	; 69
 530:	64 e0       	ldi	r22, 0x04	; 4
 532:	41 50       	subi	r20, 0x01	; 1
 534:	50 40       	sbci	r21, 0x00	; 0
 536:	60 40       	sbci	r22, 0x00	; 0
 538:	e1 f7       	brne	.-8      	; 0x532 <__stack+0x33>
 53a:	00 c0       	rjmp	.+0      	; 0x53c <__stack+0x3d>
 53c:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 53e:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 540:	81 83       	std	Z+1, r24	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 542:	80 83       	st	Z, r24
 544:	7f eb       	ldi	r23, 0xBF	; 191
 546:	85 e4       	ldi	r24, 0x45	; 69
 548:	94 e0       	ldi	r25, 0x04	; 4
 54a:	71 50       	subi	r23, 0x01	; 1
 54c:	80 40       	sbci	r24, 0x00	; 0
 54e:	90 40       	sbci	r25, 0x00	; 0
 550:	e1 f7       	brne	.-8      	; 0x54a <__stack+0x4b>
 552:	00 c0       	rjmp	.+0      	; 0x554 <__stack+0x55>
 554:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 556:	e0 e0       	ldi	r30, 0x00	; 0
 558:	f1 e0       	ldi	r31, 0x01	; 1
 55a:	80 e1       	ldi	r24, 0x10	; 16
 55c:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 55e:	81 83       	std	Z+1, r24	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 560:	80 83       	st	Z, r24
 562:	af eb       	ldi	r26, 0xBF	; 191
 564:	25 e4       	ldi	r18, 0x45	; 69
 566:	34 e0       	ldi	r19, 0x04	; 4
 568:	a1 50       	subi	r26, 0x01	; 1
 56a:	20 40       	sbci	r18, 0x00	; 0
 56c:	30 40       	sbci	r19, 0x00	; 0
 56e:	e1 f7       	brne	.-8      	; 0x568 <__stack+0x69>
 570:	00 c0       	rjmp	.+0      	; 0x572 <__stack+0x73>
 572:	00 00       	nop
 574:	08 95       	ret

00000576 <s_u8ReadSensor>:

/************************************************************************/
/* Read humidity and temperature from DHT22                             */
/************************************************************************/
uint8_t s_u8ReadSensor( void )
{
 576:	0f 93       	push	r16
 578:	1f 93       	push	r17
 57a:	cf 93       	push	r28
 57c:	df 93       	push	r29
 57e:	00 d0       	rcall	.+0      	; 0x580 <s_u8ReadSensor+0xa>
 580:	00 d0       	rcall	.+0      	; 0x582 <s_u8ReadSensor+0xc>
 582:	1f 92       	push	r1
 584:	cd b7       	in	r28, 0x3d	; 61
 586:	de b7       	in	r29, 0x3e	; 62
    uint8_t timeout = 200;
    
    SENSOR_sda_in;
 588:	3b 98       	cbi	0x07, 3	; 7

    // Bus master has released time min: 20us, typ: 30us, max: 200us
    while ( SENSOR_is_hi )
 58a:	89 ec       	ldi	r24, 0xC9	; 201
 58c:	07 c0       	rjmp	.+14     	; 0x59c <s_u8ReadSensor+0x26>
	#else
		//round up by default
		__ticks_dc = (uint32_t)(ceil(fabs(__tmp)));
	#endif

	__builtin_avr_delay_cycles(__ticks_dc);
 58e:	36 e0       	ldi	r19, 0x06	; 6
 590:	3a 95       	dec	r19
 592:	f1 f7       	brne	.-4      	; 0x590 <s_u8ReadSensor+0x1a>
 594:	00 c0       	rjmp	.+0      	; 0x596 <s_u8ReadSensor+0x20>
 596:	81 50       	subi	r24, 0x01	; 1
    {
        _delay_us(1);
        if ( !timeout-- )
 598:	09 f4       	brne	.+2      	; 0x59c <s_u8ReadSensor+0x26>
 59a:	6e c0       	rjmp	.+220    	; 0x678 <s_u8ReadSensor+0x102>
    uint8_t timeout = 200;
    
    SENSOR_sda_in;

    // Bus master has released time min: 20us, typ: 30us, max: 200us
    while ( SENSOR_is_hi )
 59c:	33 99       	sbic	0x06, 3	; 6
 59e:	f7 cf       	rjmp	.-18     	; 0x58e <s_u8ReadSensor+0x18>
 5a0:	86 e5       	ldi	r24, 0x56	; 86
 5a2:	07 c0       	rjmp	.+14     	; 0x5b2 <s_u8ReadSensor+0x3c>
 5a4:	96 e0       	ldi	r25, 0x06	; 6
 5a6:	9a 95       	dec	r25
 5a8:	f1 f7       	brne	.-4      	; 0x5a6 <s_u8ReadSensor+0x30>
 5aa:	00 c0       	rjmp	.+0      	; 0x5ac <s_u8ReadSensor+0x36>
 5ac:	81 50       	subi	r24, 0x01	; 1
    // AM2302 response signal min: 75us typ:80us max:85us
    timeout = 85;
    while(SENSOR_is_low)
    {
        _delay_us(1);
        if (!timeout--)
 5ae:	09 f4       	brne	.+2      	; 0x5b2 <s_u8ReadSensor+0x3c>
 5b0:	65 c0       	rjmp	.+202    	; 0x67c <s_u8ReadSensor+0x106>
        }
    }

    // AM2302 response signal min: 75us typ:80us max:85us
    timeout = 85;
    while(SENSOR_is_low)
 5b2:	33 9b       	sbis	0x06, 3	; 6
 5b4:	f7 cf       	rjmp	.-18     	; 0x5a4 <s_u8ReadSensor+0x2e>
 5b6:	86 e5       	ldi	r24, 0x56	; 86
 5b8:	07 c0       	rjmp	.+14     	; 0x5c8 <s_u8ReadSensor+0x52>
 5ba:	a6 e0       	ldi	r26, 0x06	; 6
 5bc:	aa 95       	dec	r26
 5be:	f1 f7       	brne	.-4      	; 0x5bc <s_u8ReadSensor+0x46>
 5c0:	00 c0       	rjmp	.+0      	; 0x5c2 <s_u8ReadSensor+0x4c>
 5c2:	81 50       	subi	r24, 0x01	; 1

    timeout = 85;
    while(SENSOR_is_hi)
    {
        _delay_us(1);
        if (!timeout--)
 5c4:	09 f4       	brne	.+2      	; 0x5c8 <s_u8ReadSensor+0x52>
 5c6:	5c c0       	rjmp	.+184    	; 0x680 <s_u8ReadSensor+0x10a>
            return 3;
        }
    }  // response to low time

    timeout = 85;
    while(SENSOR_is_hi)
 5c8:	33 99       	sbic	0x06, 3	; 6
 5ca:	f7 cf       	rjmp	.-18     	; 0x5ba <s_u8ReadSensor+0x44>
     *    signal 0 high time: 22  26  30     (bit=0)
     *    signal 1 high time: 68  70  75     (bit=1)
     *  signal 0,1 down time: 48  50  55
     */

    uint8_t sensor_data[5]={0};
 5cc:	fe 01       	movw	r30, r28
 5ce:	31 96       	adiw	r30, 0x01	; 1
 5d0:	85 e0       	ldi	r24, 0x05	; 5
 5d2:	df 01       	movw	r26, r30
 5d4:	1d 92       	st	X+, r1
 5d6:	8a 95       	dec	r24
 5d8:	e9 f7       	brne	.-6      	; 0x5d4 <s_u8ReadSensor+0x5e>
 5da:	ae 01       	movw	r20, r28
 5dc:	4a 5f       	subi	r20, 0xFA	; 250
 5de:	5f 4f       	sbci	r21, 0xFF	; 255
 5e0:	22 c0       	rjmp	.+68     	; 0x626 <s_u8ReadSensor+0xb0>
 5e2:	b6 e0       	ldi	r27, 0x06	; 6
 5e4:	ba 95       	dec	r27
 5e6:	f1 f7       	brne	.-4      	; 0x5e4 <s_u8ReadSensor+0x6e>
 5e8:	00 c0       	rjmp	.+0      	; 0x5ea <s_u8ReadSensor+0x74>
 5ea:	91 50       	subi	r25, 0x01	; 1
            while(SENSOR_is_low)
            {
                _delay_us(1);

                // if timeout == 0 => sensor do not response
                if (!timeout--)
 5ec:	11 f4       	brne	.+4      	; 0x5f2 <s_u8ReadSensor+0x7c>
 5ee:	4a c0       	rjmp	.+148    	; 0x684 <s_u8ReadSensor+0x10e>
 5f0:	98 e3       	ldi	r25, 0x38	; 56
        // get 8 bits from sensor
        for(uint8_t j = 1; j <= 8; j++)
        {
            // wait for sensor response
            timeout = 55;
            while(SENSOR_is_low)
 5f2:	33 9b       	sbis	0x06, 3	; 6
 5f4:	f6 cf       	rjmp	.-20     	; 0x5e2 <s_u8ReadSensor+0x6c>
 5f6:	38 ec       	ldi	r19, 0xC8	; 200
 5f8:	3a 95       	dec	r19
 5fa:	f1 f7       	brne	.-4      	; 0x5f8 <s_u8ReadSensor+0x82>
                }
            }

            // wait 30 us to check if bit is logical "1" or "0"
            _delay_us(30);
            sensor_byte <<= 1; // add new lower bit
 5fc:	22 0f       	add	r18, r18

            // If sda ist high after 30 us then bit is logical "1" else it was a logical "0"
            // For a logical "1" sda have to be low after 75 us.
            if (SENSOR_is_hi)
 5fe:	33 99       	sbic	0x06, 3	; 6
 600:	08 c0       	rjmp	.+16     	; 0x612 <s_u8ReadSensor+0x9c>
 602:	0b c0       	rjmp	.+22     	; 0x61a <s_u8ReadSensor+0xa4>
 604:	a6 e0       	ldi	r26, 0x06	; 6
 606:	aa 95       	dec	r26
 608:	f1 f7       	brne	.-4      	; 0x606 <s_u8ReadSensor+0x90>
 60a:	00 c0       	rjmp	.+0      	; 0x60c <s_u8ReadSensor+0x96>
 60c:	91 50       	subi	r25, 0x01	; 1

                while(SENSOR_is_hi)
                {
                    _delay_us(1);
                
                    if (!timeout--)
 60e:	11 f4       	brne	.+4      	; 0x614 <s_u8ReadSensor+0x9e>
 610:	3b c0       	rjmp	.+118    	; 0x688 <s_u8ReadSensor+0x112>
 612:	9e e2       	ldi	r25, 0x2E	; 46
            if (SENSOR_is_hi)
            {
                sensor_byte |= 1; // add logical "1"
                timeout = 45;  // 30us - 75us = 45us

                while(SENSOR_is_hi)
 614:	33 99       	sbic	0x06, 3	; 6
 616:	f6 cf       	rjmp	.-20     	; 0x604 <s_u8ReadSensor+0x8e>

            // If sda ist high after 30 us then bit is logical "1" else it was a logical "0"
            // For a logical "1" sda have to be low after 75 us.
            if (SENSOR_is_hi)
            {
                sensor_byte |= 1; // add logical "1"
 618:	21 60       	ori	r18, 0x01	; 1
 61a:	81 50       	subi	r24, 0x01	; 1
    for(uint8_t i = 0; i < 5; i++)
    {
        uint8_t sensor_byte = 0;
    
        // get 8 bits from sensor
        for(uint8_t j = 1; j <= 8; j++)
 61c:	49 f7       	brne	.-46     	; 0x5f0 <s_u8ReadSensor+0x7a>
                    }
                }
            }
        }

        sensor_data[i] = sensor_byte;
 61e:	21 93       	st	Z+, r18
     *  signal 0,1 down time: 48  50  55
     */

    uint8_t sensor_data[5]={0};

    for(uint8_t i = 0; i < 5; i++)
 620:	4e 17       	cp	r20, r30
 622:	5f 07       	cpc	r21, r31
 624:	19 f0       	breq	.+6      	; 0x62c <s_u8ReadSensor+0xb6>
 626:	88 e0       	ldi	r24, 0x08	; 8
 628:	20 e0       	ldi	r18, 0x00	; 0
 62a:	e2 cf       	rjmp	.-60     	; 0x5f0 <s_u8ReadSensor+0x7a>

        sensor_data[i] = sensor_byte;
    }

    // checksum
    if ( ((sensor_data[0] + sensor_data[1] + sensor_data[2] + sensor_data[3]) & 0xff ) != sensor_data[4])
 62c:	a9 81       	ldd	r26, Y+1	; 0x01
 62e:	b0 e0       	ldi	r27, 0x00	; 0
 630:	ea 81       	ldd	r30, Y+2	; 0x02
 632:	f0 e0       	ldi	r31, 0x00	; 0
 634:	6b 81       	ldd	r22, Y+3	; 0x03
 636:	70 e0       	ldi	r23, 0x00	; 0
 638:	4c 81       	ldd	r20, Y+4	; 0x04
 63a:	50 e0       	ldi	r21, 0x00	; 0
 63c:	9d 01       	movw	r18, r26
 63e:	2e 0f       	add	r18, r30
 640:	3f 1f       	adc	r19, r31
 642:	26 0f       	add	r18, r22
 644:	37 1f       	adc	r19, r23
 646:	24 0f       	add	r18, r20
 648:	35 1f       	adc	r19, r21
 64a:	33 27       	eor	r19, r19
 64c:	0d 81       	ldd	r16, Y+5	; 0x05
 64e:	10 e0       	ldi	r17, 0x00	; 0
 650:	20 17       	cp	r18, r16
 652:	31 07       	cpc	r19, r17
 654:	d9 f4       	brne	.+54     	; 0x68c <s_u8ReadSensor+0x116>
        // debug output
        //printf("%b %b %b %b %b %b" CR, sensor_data[0], sensor_data[1], sensor_data[2], sensor_data[3], sensor_data[4], ((sensor_data[0]+sensor_data[1]+sensor_data[2]+sensor_data[3]) & 0xff ));
        return 7;
    }

    g_u16Humidity = (sensor_data[0] << 8) + sensor_data[1];
 656:	ba 2f       	mov	r27, r26
 658:	aa 27       	eor	r26, r26
 65a:	ea 0f       	add	r30, r26
 65c:	fb 1f       	adc	r31, r27
 65e:	f0 93 28 01 	sts	0x0128, r31	; 0x800128 <g_u16Humidity+0x1>
 662:	e0 93 27 01 	sts	0x0127, r30	; 0x800127 <g_u16Humidity>
    g_u16Temperature = (sensor_data[2] << 8) + sensor_data[3];
 666:	76 2f       	mov	r23, r22
 668:	66 27       	eor	r22, r22
 66a:	46 0f       	add	r20, r22
 66c:	57 1f       	adc	r21, r23
 66e:	50 93 26 01 	sts	0x0126, r21	; 0x800126 <g_u16Temperature+0x1>
 672:	40 93 25 01 	sts	0x0125, r20	; 0x800125 <g_u16Temperature>

    return 0;
 676:	0b c0       	rjmp	.+22     	; 0x68e <s_u8ReadSensor+0x118>
    while ( SENSOR_is_hi )
    {
        _delay_us(1);
        if ( !timeout-- )
        {
            return 2;
 678:	82 e0       	ldi	r24, 0x02	; 2
 67a:	09 c0       	rjmp	.+18     	; 0x68e <s_u8ReadSensor+0x118>
    while(SENSOR_is_low)
    {
        _delay_us(1);
        if (!timeout--)
        {
            return 3;
 67c:	83 e0       	ldi	r24, 0x03	; 3
 67e:	07 c0       	rjmp	.+14     	; 0x68e <s_u8ReadSensor+0x118>
    while(SENSOR_is_hi)
    {
        _delay_us(1);
        if (!timeout--)
        {
            return 4;
 680:	84 e0       	ldi	r24, 0x04	; 4
 682:	05 c0       	rjmp	.+10     	; 0x68e <s_u8ReadSensor+0x118>
                _delay_us(1);

                // if timeout == 0 => sensor do not response
                if (!timeout--)
                {
                    return 5;
 684:	85 e0       	ldi	r24, 0x05	; 5
 686:	03 c0       	rjmp	.+6      	; 0x68e <s_u8ReadSensor+0x118>
                {
                    _delay_us(1);
                
                    if (!timeout--)
                    {
                        return 6;
 688:	86 e0       	ldi	r24, 0x06	; 6
 68a:	01 c0       	rjmp	.+2      	; 0x68e <s_u8ReadSensor+0x118>
    // checksum
    if ( ((sensor_data[0] + sensor_data[1] + sensor_data[2] + sensor_data[3]) & 0xff ) != sensor_data[4])
    {
        // debug output
        //printf("%b %b %b %b %b %b" CR, sensor_data[0], sensor_data[1], sensor_data[2], sensor_data[3], sensor_data[4], ((sensor_data[0]+sensor_data[1]+sensor_data[2]+sensor_data[3]) & 0xff ));
        return 7;
 68c:	87 e0       	ldi	r24, 0x07	; 7

    g_u16Humidity = (sensor_data[0] << 8) + sensor_data[1];
    g_u16Temperature = (sensor_data[2] << 8) + sensor_data[3];

    return 0;
 68e:	0f 90       	pop	r0
 690:	0f 90       	pop	r0
 692:	0f 90       	pop	r0
 694:	0f 90       	pop	r0
 696:	0f 90       	pop	r0
 698:	df 91       	pop	r29
 69a:	cf 91       	pop	r28
 69c:	1f 91       	pop	r17
 69e:	0f 91       	pop	r16
 6a0:	08 95       	ret

000006a2 <main>:
int main(void)
{
    uint8_t u8ErrorCode = 0U;
    uint8_t u8Loop = 0U;

    s_vInit();
 6a2:	e4 dc       	rcall	.-1592   	; 0x6c <s_vInit>
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 6a4:	e0 e0       	ldi	r30, 0x00	; 0
 6a6:	f1 e0       	ldi	r31, 0x01	; 1
 6a8:	90 e1       	ldi	r25, 0x10	; 16
 6aa:	92 83       	std	Z+2, r25	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 6ac:	91 83       	std	Z+1, r25	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 6ae:	90 83       	st	Z, r25
	#else
		//round up by default
		__ticks_dc = (uint32_t)(ceil(fabs(__tmp)));
	#endif

	__builtin_avr_delay_cycles(__ticks_dc);
 6b0:	af e4       	ldi	r26, 0x4F	; 79
 6b2:	b3 ec       	ldi	r27, 0xC3	; 195
 6b4:	11 97       	sbiw	r26, 0x01	; 1
 6b6:	f1 f7       	brne	.-4      	; 0x6b4 <main+0x12>
 6b8:	00 c0       	rjmp	.+0      	; 0x6ba <main+0x18>
 6ba:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 6bc:	83 e1       	ldi	r24, 0x13	; 19
 6be:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 6c0:	91 83       	std	Z+1, r25	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 6c2:	90 83       	st	Z, r25
 6c4:	bf e7       	ldi	r27, 0x7F	; 127
 6c6:	0f e4       	ldi	r16, 0x4F	; 79
 6c8:	12 e1       	ldi	r17, 0x12	; 18
 6ca:	b1 50       	subi	r27, 0x01	; 1
 6cc:	00 40       	sbci	r16, 0x00	; 0
 6ce:	10 40       	sbci	r17, 0x00	; 0
 6d0:	e1 f7       	brne	.-8      	; 0x6ca <main+0x28>
 6d2:	00 c0       	rjmp	.+0      	; 0x6d4 <main+0x32>
 6d4:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 6d6:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 6d8:	81 83       	std	Z+1, r24	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 6da:	90 83       	st	Z, r25
 6dc:	2f e7       	ldi	r18, 0x7F	; 127
 6de:	3f e4       	ldi	r19, 0x4F	; 79
 6e0:	42 e1       	ldi	r20, 0x12	; 18
 6e2:	21 50       	subi	r18, 0x01	; 1
 6e4:	30 40       	sbci	r19, 0x00	; 0
 6e6:	40 40       	sbci	r20, 0x00	; 0
 6e8:	e1 f7       	brne	.-8      	; 0x6e2 <main+0x40>
 6ea:	00 c0       	rjmp	.+0      	; 0x6ec <main+0x4a>
 6ec:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 6ee:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 6f0:	81 83       	std	Z+1, r24	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 6f2:	80 83       	st	Z, r24
 6f4:	8f e7       	ldi	r24, 0x7F	; 127
 6f6:	9f e4       	ldi	r25, 0x4F	; 79
 6f8:	a2 e1       	ldi	r26, 0x12	; 18
 6fa:	81 50       	subi	r24, 0x01	; 1
 6fc:	90 40       	sbci	r25, 0x00	; 0
 6fe:	a0 40       	sbci	r26, 0x00	; 0
 700:	e1 f7       	brne	.-8      	; 0x6fa <main+0x58>
 702:	00 c0       	rjmp	.+0      	; 0x704 <main+0x62>
 704:	00 00       	nop
 706:	35 e0       	ldi	r19, 0x05	; 5
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 708:	80 e1       	ldi	r24, 0x10	; 16
    g_au8Digits[DIGIT_ONES] = u8Ones;
 70a:	23 e1       	ldi	r18, 0x13	; 19
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 70c:	d9 e1       	ldi	r29, 0x19	; 25
 70e:	c7 e0       	ldi	r28, 0x07	; 7
 710:	ba e1       	ldi	r27, 0x1A	; 26
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
    g_au8Digits[DIGIT_ONES] = u8Ones;
 712:	96 e1       	ldi	r25, 0x16	; 22
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 714:	ab e1       	ldi	r26, 0x1B	; 27
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 716:	7c e1       	ldi	r23, 0x1C	; 28
 718:	6d e1       	ldi	r22, 0x1D	; 29
 71a:	5e e1       	ldi	r21, 0x1E	; 30
 71c:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 71e:	21 83       	std	Z+1, r18	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 720:	d0 83       	st	Z, r29
 722:	0f eb       	ldi	r16, 0xBF	; 191
 724:	15 e4       	ldi	r17, 0x45	; 69
 726:	44 e0       	ldi	r20, 0x04	; 4
 728:	01 50       	subi	r16, 0x01	; 1
 72a:	10 40       	sbci	r17, 0x00	; 0
 72c:	40 40       	sbci	r20, 0x00	; 0
 72e:	e1 f7       	brne	.-8      	; 0x728 <main+0x86>
 730:	00 c0       	rjmp	.+0      	; 0x732 <main+0x90>
 732:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 734:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 736:	81 83       	std	Z+1, r24	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 738:	c0 83       	st	Z, r28
 73a:	0f eb       	ldi	r16, 0xBF	; 191
 73c:	15 e4       	ldi	r17, 0x45	; 69
 73e:	44 e0       	ldi	r20, 0x04	; 4
 740:	01 50       	subi	r16, 0x01	; 1
 742:	10 40       	sbci	r17, 0x00	; 0
 744:	40 40       	sbci	r20, 0x00	; 0
 746:	e1 f7       	brne	.-8      	; 0x740 <main+0x9e>
 748:	00 c0       	rjmp	.+0      	; 0x74a <main+0xa8>
 74a:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 74c:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 74e:	81 83       	std	Z+1, r24	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 750:	b0 83       	st	Z, r27
 752:	0f eb       	ldi	r16, 0xBF	; 191
 754:	15 e4       	ldi	r17, 0x45	; 69
 756:	44 e0       	ldi	r20, 0x04	; 4
 758:	01 50       	subi	r16, 0x01	; 1
 75a:	10 40       	sbci	r17, 0x00	; 0
 75c:	40 40       	sbci	r20, 0x00	; 0
 75e:	e1 f7       	brne	.-8      	; 0x758 <main+0xb6>
 760:	00 c0       	rjmp	.+0      	; 0x762 <main+0xc0>
 762:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 764:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 766:	91 83       	std	Z+1, r25	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 768:	a0 83       	st	Z, r26
 76a:	0f eb       	ldi	r16, 0xBF	; 191
 76c:	15 e4       	ldi	r17, 0x45	; 69
 76e:	44 e0       	ldi	r20, 0x04	; 4
 770:	01 50       	subi	r16, 0x01	; 1
 772:	10 40       	sbci	r17, 0x00	; 0
 774:	40 40       	sbci	r20, 0x00	; 0
 776:	e1 f7       	brne	.-8      	; 0x770 <main+0xce>
 778:	00 c0       	rjmp	.+0      	; 0x77a <main+0xd8>
 77a:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 77c:	92 83       	std	Z+2, r25	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 77e:	91 83       	std	Z+1, r25	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 780:	90 83       	st	Z, r25
 782:	0f eb       	ldi	r16, 0xBF	; 191
 784:	15 e4       	ldi	r17, 0x45	; 69
 786:	44 e0       	ldi	r20, 0x04	; 4
 788:	01 50       	subi	r16, 0x01	; 1
 78a:	10 40       	sbci	r17, 0x00	; 0
 78c:	40 40       	sbci	r20, 0x00	; 0
 78e:	e1 f7       	brne	.-8      	; 0x788 <main+0xe6>
 790:	00 c0       	rjmp	.+0      	; 0x792 <main+0xf0>
 792:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 794:	72 83       	std	Z+2, r23	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 796:	91 83       	std	Z+1, r25	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 798:	80 83       	st	Z, r24
 79a:	0f eb       	ldi	r16, 0xBF	; 191
 79c:	15 e4       	ldi	r17, 0x45	; 69
 79e:	44 e0       	ldi	r20, 0x04	; 4
 7a0:	01 50       	subi	r16, 0x01	; 1
 7a2:	10 40       	sbci	r17, 0x00	; 0
 7a4:	40 40       	sbci	r20, 0x00	; 0
 7a6:	e1 f7       	brne	.-8      	; 0x7a0 <main+0xfe>
 7a8:	00 c0       	rjmp	.+0      	; 0x7aa <main+0x108>
 7aa:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 7ac:	62 83       	std	Z+2, r22	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 7ae:	81 83       	std	Z+1, r24	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 7b0:	80 83       	st	Z, r24
 7b2:	0f eb       	ldi	r16, 0xBF	; 191
 7b4:	15 e4       	ldi	r17, 0x45	; 69
 7b6:	44 e0       	ldi	r20, 0x04	; 4
 7b8:	01 50       	subi	r16, 0x01	; 1
 7ba:	10 40       	sbci	r17, 0x00	; 0
 7bc:	40 40       	sbci	r20, 0x00	; 0
 7be:	e1 f7       	brne	.-8      	; 0x7b8 <main+0x116>
 7c0:	00 c0       	rjmp	.+0      	; 0x7c2 <main+0x120>
 7c2:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 7c4:	52 83       	std	Z+2, r21	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 7c6:	81 83       	std	Z+1, r24	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 7c8:	80 83       	st	Z, r24
 7ca:	0f eb       	ldi	r16, 0xBF	; 191
 7cc:	15 e4       	ldi	r17, 0x45	; 69
 7ce:	44 e0       	ldi	r20, 0x04	; 4
 7d0:	01 50       	subi	r16, 0x01	; 1
 7d2:	10 40       	sbci	r17, 0x00	; 0
 7d4:	40 40       	sbci	r20, 0x00	; 0
 7d6:	e1 f7       	brne	.-8      	; 0x7d0 <main+0x12e>
 7d8:	00 c0       	rjmp	.+0      	; 0x7da <main+0x138>
 7da:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 7dc:	0f e1       	ldi	r16, 0x1F	; 31
 7de:	02 83       	std	Z+2, r16	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 7e0:	21 83       	std	Z+1, r18	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 7e2:	80 83       	st	Z, r24
 7e4:	1f eb       	ldi	r17, 0xBF	; 191
 7e6:	45 e4       	ldi	r20, 0x45	; 69
 7e8:	04 e0       	ldi	r16, 0x04	; 4
 7ea:	11 50       	subi	r17, 0x01	; 1
 7ec:	40 40       	sbci	r20, 0x00	; 0
 7ee:	00 40       	sbci	r16, 0x00	; 0
 7f0:	e1 f7       	brne	.-8      	; 0x7ea <main+0x148>
 7f2:	00 c0       	rjmp	.+0      	; 0x7f4 <main+0x152>
 7f4:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 7f6:	22 83       	std	Z+2, r18	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 7f8:	21 83       	std	Z+1, r18	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 7fa:	20 83       	st	Z, r18
 7fc:	1f eb       	ldi	r17, 0xBF	; 191
 7fe:	45 e4       	ldi	r20, 0x45	; 69
 800:	04 e0       	ldi	r16, 0x04	; 4
 802:	11 50       	subi	r17, 0x01	; 1
 804:	40 40       	sbci	r20, 0x00	; 0
 806:	00 40       	sbci	r16, 0x00	; 0
 808:	e1 f7       	brne	.-8      	; 0x802 <main+0x160>
 80a:	00 c0       	rjmp	.+0      	; 0x80c <main+0x16a>
 80c:	00 00       	nop
 80e:	31 50       	subi	r19, 0x01	; 1
    s_vSetDisplayDigits( SYM_SEG_A, SYM_SEG_A, SYM_OFF );
    _delay_ms(300);
    s_vSetDisplayDigits( SYM_SEG_A, SYM_SEG_A, SYM_SEG_A );
    _delay_ms(300);
    
    while ( u8Loop < 5U )
 810:	09 f0       	breq	.+2      	; 0x814 <main+0x172>
 812:	84 cf       	rjmp	.-248    	; 0x71c <main+0x7a>
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 814:	e0 e0       	ldi	r30, 0x00	; 0
 816:	f1 e0       	ldi	r31, 0x01	; 1
 818:	80 e1       	ldi	r24, 0x10	; 16
 81a:	82 83       	std	Z+2, r24	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 81c:	81 83       	std	Z+1, r24	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 81e:	80 83       	st	Z, r24
 820:	1f ef       	ldi	r17, 0xFF	; 255
 822:	2e e9       	ldi	r18, 0x9E	; 158
 824:	34 e2       	ldi	r19, 0x24	; 36
 826:	11 50       	subi	r17, 0x01	; 1
 828:	20 40       	sbci	r18, 0x00	; 0
 82a:	30 40       	sbci	r19, 0x00	; 0
 82c:	e1 f7       	brne	.-8      	; 0x826 <main+0x184>
 82e:	00 c0       	rjmp	.+0      	; 0x830 <main+0x18e>
 830:	00 00       	nop
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 832:	ef 01       	movw	r28, r30
 834:	0c e0       	ldi	r16, 0x0C	; 12
    g_au8Digits[DIGIT_ONES] = u8Ones;
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 836:	10 e1       	ldi	r17, 0x10	; 16
    s_vSetDisplayDigits( SYM_OFF, SYM_OFF, SYM_OFF );
    _delay_ms(600);

    while ( 1 )
    {
        switch ( g_u8Mode )
 838:	80 91 29 01 	lds	r24, 0x0129	; 0x800129 <g_u8Mode>
 83c:	81 30       	cpi	r24, 0x01	; 1
 83e:	b1 f1       	breq	.+108    	; 0x8ac <main+0x20a>
 840:	20 f0       	brcs	.+8      	; 0x84a <main+0x1a8>
 842:	82 30       	cpi	r24, 0x02	; 2
 844:	09 f4       	brne	.+2      	; 0x848 <main+0x1a6>
 846:	40 c0       	rjmp	.+128    	; 0x8c8 <main+0x226>
 848:	f9 cf       	rjmp	.-14     	; 0x83c <main+0x19a>
        {
            case MODE_MEASURE:
                if ( SENSOR_is_hi )
 84a:	33 9b       	sbis	0x06, 3	; 6
 84c:	25 c0       	rjmp	.+74     	; 0x898 <main+0x1f6>
                {
                    SENSOR_sda_out;
 84e:	3b 9a       	sbi	0x07, 3	; 7
                    SENSOR_sda_low;
 850:	43 98       	cbi	0x08, 3	; 8
 852:	4f e7       	ldi	r20, 0x7F	; 127
 854:	88 e3       	ldi	r24, 0x38	; 56
 856:	91 e0       	ldi	r25, 0x01	; 1
 858:	41 50       	subi	r20, 0x01	; 1
 85a:	80 40       	sbci	r24, 0x00	; 0
 85c:	90 40       	sbci	r25, 0x00	; 0
 85e:	e1 f7       	brne	.-8      	; 0x858 <main+0x1b6>
 860:	00 c0       	rjmp	.+0      	; 0x862 <main+0x1c0>
 862:	00 00       	nop
                    _delay_ms(20);
                    u8ErrorCode = s_u8ReadSensor();
 864:	88 de       	rcall	.-752    	; 0x576 <s_u8ReadSensor>
                    if ( 0U == u8ErrorCode )
 866:	81 11       	cpse	r24, r1
 868:	10 c0       	rjmp	.+32     	; 0x88a <main+0x1e8>
                    {
                        s_vSetValue( g_u16Humidity / 10, SYM_P_P );
 86a:	20 91 27 01 	lds	r18, 0x0127	; 0x800127 <g_u16Humidity>
 86e:	30 91 28 01 	lds	r19, 0x0128	; 0x800128 <g_u16Humidity+0x1>
 872:	ad ec       	ldi	r26, 0xCD	; 205
 874:	bc ec       	ldi	r27, 0xCC	; 204
 876:	36 d0       	rcall	.+108    	; 0x8e4 <__umulhisi3>
 878:	96 95       	lsr	r25
 87a:	87 95       	ror	r24
 87c:	96 95       	lsr	r25
 87e:	87 95       	ror	r24
 880:	96 95       	lsr	r25
 882:	87 95       	ror	r24
 884:	6f e0       	ldi	r22, 0x0F	; 15
 886:	0c dc       	rcall	.-2024   	; 0xa0 <s_vSetValue>
 888:	03 c0       	rjmp	.+6      	; 0x890 <main+0x1ee>
/************************************************************************/
/* Set display digits individually                                      */
/************************************************************************/
void s_vSetDisplayDigits( uint8_t u8Tens, uint8_t u8Ones, uint8_t u8Unit )
{
    g_au8Digits[DIGIT_TENS] = u8Tens;
 88a:	0a 83       	std	Y+2, r16	; 0x02
    g_au8Digits[DIGIT_ONES] = u8Ones;
 88c:	89 83       	std	Y+1, r24	; 0x01
    g_au8Digits[DIGIT_UNIT] = u8Unit;
 88e:	18 83       	st	Y, r17
                    else
                    {
                        s_vSetDisplayDigits( SYM_E, u8ErrorCode, SYM_OFF );
                    }
                }
                if ( g_u8Mode == MODE_MEASURE )
 890:	80 91 29 01 	lds	r24, 0x0129	; 0x800129 <g_u8Mode>
 894:	81 11       	cpse	r24, r1
 896:	d0 cf       	rjmp	.-96     	; 0x838 <main+0x196>
 898:	af e7       	ldi	r26, 0x7F	; 127
 89a:	b4 e8       	ldi	r27, 0x84	; 132
 89c:	2e e1       	ldi	r18, 0x1E	; 30
 89e:	a1 50       	subi	r26, 0x01	; 1
 8a0:	b0 40       	sbci	r27, 0x00	; 0
 8a2:	20 40       	sbci	r18, 0x00	; 0
 8a4:	e1 f7       	brne	.-8      	; 0x89e <main+0x1fc>
 8a6:	00 c0       	rjmp	.+0      	; 0x8a8 <main+0x206>
 8a8:	00 00       	nop
 8aa:	c6 cf       	rjmp	.-116    	; 0x838 <main+0x196>
                {
                    _delay_ms(500);
                }
                break;
            case MODE_ANIMATION_1:
                s_vShowAnim(g_u8Mode);
 8ac:	81 e0       	ldi	r24, 0x01	; 1
 8ae:	7d dc       	rcall	.-1798   	; 0x1aa <s_vShowAnim>
                g_u8Mode = MODE_MEASURE;
 8b0:	10 92 29 01 	sts	0x0129, r1	; 0x800129 <g_u8Mode>
 8b4:	3f ef       	ldi	r19, 0xFF	; 255
 8b6:	44 e3       	ldi	r20, 0x34	; 52
 8b8:	8c e0       	ldi	r24, 0x0C	; 12
 8ba:	31 50       	subi	r19, 0x01	; 1
 8bc:	40 40       	sbci	r20, 0x00	; 0
 8be:	80 40       	sbci	r24, 0x00	; 0
 8c0:	e1 f7       	brne	.-8      	; 0x8ba <main+0x218>
 8c2:	00 c0       	rjmp	.+0      	; 0x8c4 <main+0x222>
 8c4:	00 00       	nop
 8c6:	b8 cf       	rjmp	.-144    	; 0x838 <main+0x196>
                _delay_ms(200);
                break;
            case MODE_ANIMATION_2:
                s_vShowAnim(g_u8Mode);
 8c8:	82 e0       	ldi	r24, 0x02	; 2
 8ca:	6f dc       	rcall	.-1826   	; 0x1aa <s_vShowAnim>
                g_u8Mode = MODE_MEASURE;
 8cc:	10 92 29 01 	sts	0x0129, r1	; 0x800129 <g_u8Mode>
 8d0:	9f ef       	ldi	r25, 0xFF	; 255
 8d2:	a4 e3       	ldi	r26, 0x34	; 52
 8d4:	bc e0       	ldi	r27, 0x0C	; 12
 8d6:	91 50       	subi	r25, 0x01	; 1
 8d8:	a0 40       	sbci	r26, 0x00	; 0
 8da:	b0 40       	sbci	r27, 0x00	; 0
 8dc:	e1 f7       	brne	.-8      	; 0x8d6 <main+0x234>
 8de:	00 c0       	rjmp	.+0      	; 0x8e0 <main+0x23e>
 8e0:	00 00       	nop
 8e2:	aa cf       	rjmp	.-172    	; 0x838 <main+0x196>

000008e4 <__umulhisi3>:
 8e4:	a2 9f       	mul	r26, r18
 8e6:	b0 01       	movw	r22, r0
 8e8:	b3 9f       	mul	r27, r19
 8ea:	c0 01       	movw	r24, r0
 8ec:	a3 9f       	mul	r26, r19
 8ee:	01 d0       	rcall	.+2      	; 0x8f2 <__umulhisi3+0xe>
 8f0:	b2 9f       	mul	r27, r18
 8f2:	70 0d       	add	r23, r0
 8f4:	81 1d       	adc	r24, r1
 8f6:	11 24       	eor	r1, r1
 8f8:	91 1d       	adc	r25, r1
 8fa:	08 95       	ret

000008fc <_exit>:
 8fc:	f8 94       	cli

000008fe <__stop_program>:
 8fe:	ff cf       	rjmp	.-2      	; 0x8fe <__stop_program>