julian
/
poolclock
1
0
Forka 0
Codice Problemi 0 Pull Requests 0 Rilasci 0 Wiki Attività
Non puoi selezionare più di 25 argomenti Gli argomenti devono iniziare con una lettera o un numero, possono includere trattini ('-') e possono essere lunghi fino a 35 caratteri.
1 Commit
1 Ramo (Branch)
196 KiB
 
 
Ramo (Branch): master
Rami (Branch) Tag
${ item.name }
Crea branch ${ searchTerm }
da 'master'
${ noResults }
poolclock/PoolClock/Debug/PoolClock.lss

716 righe
25 KiB
Originale Permalink Blame Cronologia 

  1. 

  2. PoolClock.elf:     file format elf32-avr

  3. 

  4. Sections:

  5. Idx Name          Size      VMA       LMA       File off  Algn

  6.   0 .data         0000000e  00800100  000002de  00000372  2**0

  7.                   CONTENTS, ALLOC, LOAD, DATA

  8.   1 .text         000002de  00000000  00000000  00000094  2**1

  9.                   CONTENTS, ALLOC, LOAD, READONLY, CODE

  10.   2 .bss          00000006  0080010e  0080010e  00000380  2**0

  11.                   ALLOC

  12.   3 .comment      00000030  00000000  00000000  00000380  2**0

  13.                   CONTENTS, READONLY

  14.   4 .note.gnu.avr.deviceinfo 00000040  00000000  00000000  000003b0  2**2

  15.                   CONTENTS, READONLY

  16.   5 .debug_aranges 00000048  00000000  00000000  000003f0  2**0

  17.                   CONTENTS, READONLY, DEBUGGING

  18.   6 .debug_info   00000bbe  00000000  00000000  00000438  2**0

  19.                   CONTENTS, READONLY, DEBUGGING

  20.   7 .debug_abbrev 00000784  00000000  00000000  00000ff6  2**0

  21.                   CONTENTS, READONLY, DEBUGGING

  22.   8 .debug_line   00000507  00000000  00000000  0000177a  2**0

  23.                   CONTENTS, READONLY, DEBUGGING

  24.   9 .debug_frame  00000090  00000000  00000000  00001c84  2**2

  25.                   CONTENTS, READONLY, DEBUGGING

  26.  10 .debug_str    00000487  00000000  00000000  00001d14  2**0

  27.                   CONTENTS, READONLY, DEBUGGING

  28.  11 .debug_loc    00000634  00000000  00000000  0000219b  2**0

  29.                   CONTENTS, READONLY, DEBUGGING

  30.  12 .debug_ranges 00000098  00000000  00000000  000027cf  2**0

  31.                   CONTENTS, READONLY, DEBUGGING

  32. 

  33. Disassembly of section .text:

  34. 

  35. 00000000 <__vectors>:

  36.    0:	19 c0       	rjmp	.+50     	; 0x34 <__ctors_end>

  37.    2:	33 c0       	rjmp	.+102    	; 0x6a <__bad_interrupt>

  38.    4:	32 c0       	rjmp	.+100    	; 0x6a <__bad_interrupt>

  39.    6:	31 c0       	rjmp	.+98     	; 0x6a <__bad_interrupt>

  40.    8:	30 c0       	rjmp	.+96     	; 0x6a <__bad_interrupt>

  41.    a:	2f c0       	rjmp	.+94     	; 0x6a <__bad_interrupt>

  42.    c:	2e c0       	rjmp	.+92     	; 0x6a <__bad_interrupt>

  43.    e:	2d c0       	rjmp	.+90     	; 0x6a <__bad_interrupt>

  44.   10:	2c c0       	rjmp	.+88     	; 0x6a <__bad_interrupt>

  45.   12:	2b c0       	rjmp	.+86     	; 0x6a <__bad_interrupt>

  46.   14:	2a c0       	rjmp	.+84     	; 0x6a <__bad_interrupt>

  47.   16:	29 c0       	rjmp	.+82     	; 0x6a <__bad_interrupt>

  48.   18:	28 c0       	rjmp	.+80     	; 0x6a <__bad_interrupt>

  49.   1a:	27 c0       	rjmp	.+78     	; 0x6a <__bad_interrupt>

  50.   1c:	26 c0       	rjmp	.+76     	; 0x6a <__bad_interrupt>

  51.   1e:	25 c0       	rjmp	.+74     	; 0x6a <__bad_interrupt>

  52.   20:	24 c0       	rjmp	.+72     	; 0x6a <__bad_interrupt>

  53.   22:	23 c0       	rjmp	.+70     	; 0x6a <__bad_interrupt>

  54.   24:	22 c0       	rjmp	.+68     	; 0x6a <__bad_interrupt>

  55.   26:	21 c0       	rjmp	.+66     	; 0x6a <__bad_interrupt>

  56.   28:	20 c0       	rjmp	.+64     	; 0x6a <__bad_interrupt>

  57.   2a:	1f c0       	rjmp	.+62     	; 0x6a <__bad_interrupt>

  58.   2c:	1e c0       	rjmp	.+60     	; 0x6a <__bad_interrupt>

  59.   2e:	1d c0       	rjmp	.+58     	; 0x6a <__bad_interrupt>

  60.   30:	1c c0       	rjmp	.+56     	; 0x6a <__bad_interrupt>

  61.   32:	1b c0       	rjmp	.+54     	; 0x6a <__bad_interrupt>

  62. 

  63. 00000034 <__ctors_end>:

  64.   34:	11 24       	eor	r1, r1

  65.   36:	1f be       	out	0x3f, r1	; 63

  66.   38:	cf ef       	ldi	r28, 0xFF	; 255

  67.   3a:	d4 e0       	ldi	r29, 0x04	; 4

  68.   3c:	de bf       	out	0x3e, r29	; 62

  69.   3e:	cd bf       	out	0x3d, r28	; 61

  70. 

  71. 00000040 <__do_copy_data>:

  72.   40:	11 e0       	ldi	r17, 0x01	; 1

  73.   42:	a0 e0       	ldi	r26, 0x00	; 0

  74.   44:	b1 e0       	ldi	r27, 0x01	; 1

  75.   46:	ee ed       	ldi	r30, 0xDE	; 222

  76.   48:	f2 e0       	ldi	r31, 0x02	; 2

  77.   4a:	02 c0       	rjmp	.+4      	; 0x50 <__do_copy_data+0x10>

  78.   4c:	05 90       	lpm	r0, Z+

  79.   4e:	0d 92       	st	X+, r0

  80.   50:	ae 30       	cpi	r26, 0x0E	; 14

  81.   52:	b1 07       	cpc	r27, r17

  82.   54:	d9 f7       	brne	.-10     	; 0x4c <__do_copy_data+0xc>

  83. 

  84. 00000056 <__do_clear_bss>:

  85.   56:	21 e0       	ldi	r18, 0x01	; 1

  86.   58:	ae e0       	ldi	r26, 0x0E	; 14

  87.   5a:	b1 e0       	ldi	r27, 0x01	; 1

  88.   5c:	01 c0       	rjmp	.+2      	; 0x60 <.do_clear_bss_start>

  89. 

  90. 0000005e <.do_clear_bss_loop>:

  91.   5e:	1d 92       	st	X+, r1

  92. 

  93. 00000060 <.do_clear_bss_start>:

  94.   60:	a4 31       	cpi	r26, 0x14	; 20

  95.   62:	b2 07       	cpc	r27, r18

  96.   64:	e1 f7       	brne	.-8      	; 0x5e <.do_clear_bss_loop>

  97.   66:	e0 d0       	rcall	.+448    	; 0x228 <main>

  98.   68:	38 c1       	rjmp	.+624    	; 0x2da <_exit>

  99. 

  100. 0000006a <__bad_interrupt>:

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

  102. 

  103. 0000006c <vInit>:

  104.         }

  105.         g_u8CountDecs = 0U; //reset decrement counter

  106.     }

  107. 

  108.     g_u8Tens = g_u8WaterTemperature / 10U;

  109.     g_u8Ones = g_u8WaterTemperature - (g_u8Tens * 10U);

  110.   6c:	8f ef       	ldi	r24, 0xFF	; 255

  111.   6e:	8a b9       	out	0x0a, r24	; 10

  112.   70:	87 e0       	ldi	r24, 0x07	; 7

  113.   72:	84 b9       	out	0x04, r24	; 4

  114.   74:	3b 98       	cbi	0x07, 3	; 7

  115.   76:	43 98       	cbi	0x08, 3	; 8

  116.   78:	2f ef       	ldi	r18, 0xFF	; 255

  117.   7a:	81 e1       	ldi	r24, 0x11	; 17

  118.   7c:	9a e7       	ldi	r25, 0x7A	; 122

  119.   7e:	21 50       	subi	r18, 0x01	; 1

  120.   80:	80 40       	sbci	r24, 0x00	; 0

  121.   82:	90 40       	sbci	r25, 0x00	; 0

  122.   84:	e1 f7       	brne	.-8      	; 0x7e <vInit+0x12>

  123.   86:	00 c0       	rjmp	.+0      	; 0x88 <vInit+0x1c>

  124.   88:	00 00       	nop

  125.   8a:	08 95       	ret

  126. 

  127. 0000008c <vShow>:

  128. /************************************************************************/

  129. /*                                                                      */

  130. /************************************************************************/

  131. void vShow( void )

  132. {

  133.     PORTD = 0U;

  134.   8c:	1b b8       	out	0x0b, r1	; 11

  135.     PORTB = SELECT_DIGIT(DIGIT_TENS);

  136.   8e:	84 e0       	ldi	r24, 0x04	; 4

  137.   90:	85 b9       	out	0x05, r24	; 5

  138. 	#else

  139. 		//round up by default

  140. 		__ticks_dc = (uint32_t)(ceil(fabs(__tmp)));

  141. 	#endif

  142. 

  143. 	__builtin_avr_delay_cycles(__ticks_dc);

  144.   92:	86 e0       	ldi	r24, 0x06	; 6

  145.   94:	8a 95       	dec	r24

  146.   96:	f1 f7       	brne	.-4      	; 0x94 <vShow+0x8>

  147.   98:	00 c0       	rjmp	.+0      	; 0x9a <vShow+0xe>

  148.     _delay_us(1);

  149.     PORTD = g_au8Numbers[g_u8Tens];

  150.   9a:	e0 91 13 01 	lds	r30, 0x0113	; 0x800113 <g_u8Tens>

  151.   9e:	f0 e0       	ldi	r31, 0x00	; 0

  152.   a0:	e0 50       	subi	r30, 0x00	; 0

  153.   a2:	ff 4f       	sbci	r31, 0xFF	; 255

  154.   a4:	80 81       	ld	r24, Z

  155.   a6:	8b b9       	out	0x0b, r24	; 11

  156. 	#else

  157. 		//round up by default

  158. 		__ticks_dc = (uint32_t)(ceil(fabs(__tmp)));

  159. 	#endif

  160. 

  161. 	__builtin_avr_delay_cycles(__ticks_dc);

  162.   a8:	87 e8       	ldi	r24, 0x87	; 135

  163.   aa:	93 e1       	ldi	r25, 0x13	; 19

  164.   ac:	01 97       	sbiw	r24, 0x01	; 1

  165.   ae:	f1 f7       	brne	.-4      	; 0xac <vShow+0x20>

  166.   b0:	00 c0       	rjmp	.+0      	; 0xb2 <vShow+0x26>

  167.   b2:	00 00       	nop

  168.     _delay_ms(MULTIPLEX_DELAY_MS);

  169.     

  170.     PORTD = 0U;

  171.   b4:	1b b8       	out	0x0b, r1	; 11

  172.     PORTB = SELECT_DIGIT(DIGIT_ONES);

  173.   b6:	82 e0       	ldi	r24, 0x02	; 2

  174.   b8:	85 b9       	out	0x05, r24	; 5

  175. 	#else

  176. 		//round up by default

  177. 		__ticks_dc = (uint32_t)(ceil(fabs(__tmp)));

  178. 	#endif

  179. 

  180. 	__builtin_avr_delay_cycles(__ticks_dc);

  181.   ba:	96 e0       	ldi	r25, 0x06	; 6

  182.   bc:	9a 95       	dec	r25

  183.   be:	f1 f7       	brne	.-4      	; 0xbc <vShow+0x30>

  184.   c0:	00 c0       	rjmp	.+0      	; 0xc2 <vShow+0x36>

  185.     _delay_us(1);

  186.     PORTD = g_au8Numbers[g_u8Ones];

  187.   c2:	e0 91 12 01 	lds	r30, 0x0112	; 0x800112 <g_u8Ones>

  188.   c6:	f0 e0       	ldi	r31, 0x00	; 0

  189.   c8:	e0 50       	subi	r30, 0x00	; 0

  190.   ca:	ff 4f       	sbci	r31, 0xFF	; 255

  191.   cc:	80 81       	ld	r24, Z

  192.   ce:	8b b9       	out	0x0b, r24	; 11

  193. 	#else

  194. 		//round up by default

  195. 		__ticks_dc = (uint32_t)(ceil(fabs(__tmp)));

  196. 	#endif

  197. 

  198. 	__builtin_avr_delay_cycles(__ticks_dc);

  199.   d0:	87 e8       	ldi	r24, 0x87	; 135

  200.   d2:	93 e1       	ldi	r25, 0x13	; 19

  201.   d4:	01 97       	sbiw	r24, 0x01	; 1

  202.   d6:	f1 f7       	brne	.-4      	; 0xd4 <vShow+0x48>

  203.   d8:	00 c0       	rjmp	.+0      	; 0xda <vShow+0x4e>

  204.   da:	00 00       	nop

  205.     _delay_ms(MULTIPLEX_DELAY_MS);

  206.     

  207.     PORTD = 0U;

  208.   dc:	1b b8       	out	0x0b, r1	; 11

  209.     PORTB = SELECT_DIGIT(DIGIT_UNIT);

  210.   de:	81 e0       	ldi	r24, 0x01	; 1

  211.   e0:	85 b9       	out	0x05, r24	; 5

  212. 	#else

  213. 		//round up by default

  214. 		__ticks_dc = (uint32_t)(ceil(fabs(__tmp)));

  215. 	#endif

  216. 

  217. 	__builtin_avr_delay_cycles(__ticks_dc);

  218.   e2:	96 e0       	ldi	r25, 0x06	; 6

  219.   e4:	9a 95       	dec	r25

  220.   e6:	f1 f7       	brne	.-4      	; 0xe4 <vShow+0x58>

  221.   e8:	00 c0       	rjmp	.+0      	; 0xea <vShow+0x5e>

  222.     _delay_us(1);

  223.     PORTD = DEGREE_CELCIUS;

  224.   ea:	8d ea       	ldi	r24, 0xAD	; 173

  225.   ec:	8b b9       	out	0x0b, r24	; 11

  226. 	#else

  227. 		//round up by default

  228. 		__ticks_dc = (uint32_t)(ceil(fabs(__tmp)));

  229. 	#endif

  230. 

  231. 	__builtin_avr_delay_cycles(__ticks_dc);

  232.   ee:	87 e8       	ldi	r24, 0x87	; 135

  233.   f0:	93 e1       	ldi	r25, 0x13	; 19

  234.   f2:	01 97       	sbiw	r24, 0x01	; 1

  235.   f4:	f1 f7       	brne	.-4      	; 0xf2 <vShow+0x66>

  236.   f6:	00 c0       	rjmp	.+0      	; 0xf8 <vShow+0x6c>

  237.   f8:	00 00       	nop

  238.   fa:	08 95       	ret

  239. 

  240. 000000fc <u8ReadSensor>:

  241. 

  242. /************************************************************************/

  243. /*                                                                      */

  244. /************************************************************************/

  245. uint8_t u8ReadSensor( void )

  246. {

  247.   fc:	0f 93       	push	r16

  248.   fe:	1f 93       	push	r17

  249.  100:	cf 93       	push	r28

  250.  102:	df 93       	push	r29

  251.  104:	00 d0       	rcall	.+0      	; 0x106 <u8ReadSensor+0xa>

  252.  106:	00 d0       	rcall	.+0      	; 0x108 <u8ReadSensor+0xc>

  253.  108:	1f 92       	push	r1

  254.  10a:	cd b7       	in	r28, 0x3d	; 61

  255.  10c:	de b7       	in	r29, 0x3e	; 62

  256.     uint8_t timeout = 200;

  257.     

  258.     SENSOR_sda_in;

  259.  10e:	3b 98       	cbi	0x07, 3	; 7

  260. 

  261.     // Bus master has released time min: 20us, typ: 30us, max: 200us

  262.     while ( SENSOR_is_hi )

  263.  110:	89 ec       	ldi	r24, 0xC9	; 201

  264.  112:	07 c0       	rjmp	.+14     	; 0x122 <u8ReadSensor+0x26>

  265. 	#else

  266. 		//round up by default

  267. 		__ticks_dc = (uint32_t)(ceil(fabs(__tmp)));

  268. 	#endif

  269. 

  270. 	__builtin_avr_delay_cycles(__ticks_dc);

  271.  114:	36 e0       	ldi	r19, 0x06	; 6

  272.  116:	3a 95       	dec	r19

  273.  118:	f1 f7       	brne	.-4      	; 0x116 <u8ReadSensor+0x1a>

  274.  11a:	00 c0       	rjmp	.+0      	; 0x11c <u8ReadSensor+0x20>

  275.  11c:	81 50       	subi	r24, 0x01	; 1

  276.     {

  277.         _delay_us(1);

  278.         if ( !timeout-- )

  279.  11e:	09 f4       	brne	.+2      	; 0x122 <u8ReadSensor+0x26>

  280.  120:	6e c0       	rjmp	.+220    	; 0x1fe <u8ReadSensor+0x102>

  281.     uint8_t timeout = 200;

  282.     

  283.     SENSOR_sda_in;

  284. 

  285.     // Bus master has released time min: 20us, typ: 30us, max: 200us

  286.     while ( SENSOR_is_hi )

  287.  122:	33 99       	sbic	0x06, 3	; 6

  288.  124:	f7 cf       	rjmp	.-18     	; 0x114 <u8ReadSensor+0x18>

  289.  126:	86 e5       	ldi	r24, 0x56	; 86

  290.  128:	07 c0       	rjmp	.+14     	; 0x138 <u8ReadSensor+0x3c>

  291.  12a:	96 e0       	ldi	r25, 0x06	; 6

  292.  12c:	9a 95       	dec	r25

  293.  12e:	f1 f7       	brne	.-4      	; 0x12c <u8ReadSensor+0x30>

  294.  130:	00 c0       	rjmp	.+0      	; 0x132 <u8ReadSensor+0x36>

  295.  132:	81 50       	subi	r24, 0x01	; 1

  296.     // AM2302 response signal min: 75us typ:80us max:85us

  297.     timeout = 85;

  298.     while(SENSOR_is_low)

  299.     {

  300.         _delay_us(1);

  301.         if (!timeout--)

  302.  134:	09 f4       	brne	.+2      	; 0x138 <u8ReadSensor+0x3c>

  303.  136:	65 c0       	rjmp	.+202    	; 0x202 <u8ReadSensor+0x106>

  304.         }

  305.     }

  306. 

  307.     // AM2302 response signal min: 75us typ:80us max:85us

  308.     timeout = 85;

  309.     while(SENSOR_is_low)

  310.  138:	33 9b       	sbis	0x06, 3	; 6

  311.  13a:	f7 cf       	rjmp	.-18     	; 0x12a <u8ReadSensor+0x2e>

  312.  13c:	86 e5       	ldi	r24, 0x56	; 86

  313.  13e:	07 c0       	rjmp	.+14     	; 0x14e <u8ReadSensor+0x52>

  314.  140:	a6 e0       	ldi	r26, 0x06	; 6

  315.  142:	aa 95       	dec	r26

  316.  144:	f1 f7       	brne	.-4      	; 0x142 <u8ReadSensor+0x46>

  317.  146:	00 c0       	rjmp	.+0      	; 0x148 <u8ReadSensor+0x4c>

  318.  148:	81 50       	subi	r24, 0x01	; 1

  319. 

  320.     timeout = 85;

  321.     while(SENSOR_is_hi)

  322.     {

  323.         _delay_us(1);

  324.         if (!timeout--)

  325.  14a:	09 f4       	brne	.+2      	; 0x14e <u8ReadSensor+0x52>

  326.  14c:	5c c0       	rjmp	.+184    	; 0x206 <u8ReadSensor+0x10a>

  327.             return 3;

  328.         }

  329.     }  // response to low time

  330. 

  331.     timeout = 85;

  332.     while(SENSOR_is_hi)

  333.  14e:	33 99       	sbic	0x06, 3	; 6

  334.  150:	f7 cf       	rjmp	.-18     	; 0x140 <u8ReadSensor+0x44>

  335.      *    signal 0 high time: 22  26  30     (bit=0)

  336.      *    signal 1 high time: 68  70  75     (bit=1)

  337.      *  signal 0,1 down time: 48  50  55

  338.      */

  339. 

  340.     uint8_t sensor_data[5]={0};

  341.  152:	fe 01       	movw	r30, r28

  342.  154:	31 96       	adiw	r30, 0x01	; 1

  343.  156:	85 e0       	ldi	r24, 0x05	; 5

  344.  158:	df 01       	movw	r26, r30

  345.  15a:	1d 92       	st	X+, r1

  346.  15c:	8a 95       	dec	r24

  347.  15e:	e9 f7       	brne	.-6      	; 0x15a <u8ReadSensor+0x5e>

  348.  160:	ae 01       	movw	r20, r28

  349.  162:	4a 5f       	subi	r20, 0xFA	; 250

  350.  164:	5f 4f       	sbci	r21, 0xFF	; 255

  351.  166:	22 c0       	rjmp	.+68     	; 0x1ac <u8ReadSensor+0xb0>

  352.  168:	b6 e0       	ldi	r27, 0x06	; 6

  353.  16a:	ba 95       	dec	r27

  354.  16c:	f1 f7       	brne	.-4      	; 0x16a <u8ReadSensor+0x6e>

  355.  16e:	00 c0       	rjmp	.+0      	; 0x170 <u8ReadSensor+0x74>

  356.  170:	91 50       	subi	r25, 0x01	; 1

  357.             while(SENSOR_is_low)

  358.             {

  359.                 _delay_us(1);

  360. 

  361.                 // if timeout == 0 => sensor do not response

  362.                 if (!timeout--)

  363.  172:	11 f4       	brne	.+4      	; 0x178 <u8ReadSensor+0x7c>

  364.  174:	4a c0       	rjmp	.+148    	; 0x20a <u8ReadSensor+0x10e>

  365.  176:	98 e3       	ldi	r25, 0x38	; 56

  366.         // get 8 bits from sensor

  367.         for(uint8_t j = 1; j <= 8; j++)

  368.         {

  369.             // wait for sensor response

  370.             timeout = 55;

  371.             while(SENSOR_is_low)

  372.  178:	33 9b       	sbis	0x06, 3	; 6

  373.  17a:	f6 cf       	rjmp	.-20     	; 0x168 <u8ReadSensor+0x6c>

  374.  17c:	38 ec       	ldi	r19, 0xC8	; 200

  375.  17e:	3a 95       	dec	r19

  376.  180:	f1 f7       	brne	.-4      	; 0x17e <u8ReadSensor+0x82>

  377.                 }

  378.             }

  379. 

  380.             // wait 30 us to check if bit is logical "1" or "0"

  381.             _delay_us(30);

  382.             sensor_byte <<= 1; // add new lower bit

  383.  182:	22 0f       	add	r18, r18

  384. 

  385.             // If sda ist high after 30 us then bit is logical "1" else it was a logical "0"

  386.             // For a logical "1" sda have to be low after 75 us.

  387.             if (SENSOR_is_hi)

  388.  184:	33 99       	sbic	0x06, 3	; 6

  389.  186:	08 c0       	rjmp	.+16     	; 0x198 <u8ReadSensor+0x9c>

  390.  188:	0b c0       	rjmp	.+22     	; 0x1a0 <u8ReadSensor+0xa4>

  391.  18a:	a6 e0       	ldi	r26, 0x06	; 6

  392.  18c:	aa 95       	dec	r26

  393.  18e:	f1 f7       	brne	.-4      	; 0x18c <u8ReadSensor+0x90>

  394.  190:	00 c0       	rjmp	.+0      	; 0x192 <u8ReadSensor+0x96>

  395.  192:	91 50       	subi	r25, 0x01	; 1

  396. 

  397.                 while(SENSOR_is_hi)

  398.                 {

  399.                     _delay_us(1);

  400.                 

  401.                     if (!timeout--)

  402.  194:	11 f4       	brne	.+4      	; 0x19a <u8ReadSensor+0x9e>

  403.  196:	3b c0       	rjmp	.+118    	; 0x20e <u8ReadSensor+0x112>

  404.  198:	9e e2       	ldi	r25, 0x2E	; 46

  405.             if (SENSOR_is_hi)

  406.             {

  407.                 sensor_byte |= 1; // add logical "1"

  408.                 timeout = 45;  // 30us - 75us = 45us

  409. 

  410.                 while(SENSOR_is_hi)

  411.  19a:	33 99       	sbic	0x06, 3	; 6

  412.  19c:	f6 cf       	rjmp	.-20     	; 0x18a <u8ReadSensor+0x8e>

  413. 

  414.             // If sda ist high after 30 us then bit is logical "1" else it was a logical "0"

  415.             // For a logical "1" sda have to be low after 75 us.

  416.             if (SENSOR_is_hi)

  417.             {

  418.                 sensor_byte |= 1; // add logical "1"

  419.  19e:	21 60       	ori	r18, 0x01	; 1

  420.  1a0:	81 50       	subi	r24, 0x01	; 1

  421.     for(uint8_t i = 0; i < 5; i++)

  422.     {

  423.         uint8_t sensor_byte = 0;

  424.     

  425.         // get 8 bits from sensor

  426.         for(uint8_t j = 1; j <= 8; j++)

  427.  1a2:	49 f7       	brne	.-46     	; 0x176 <u8ReadSensor+0x7a>

  428.                     }

  429.                 }

  430.             }

  431.         }

  432. 

  433.         sensor_data[i] = sensor_byte;

  434.  1a4:	21 93       	st	Z+, r18

  435.      *  signal 0,1 down time: 48  50  55

  436.      */

  437. 

  438.     uint8_t sensor_data[5]={0};

  439. 

  440.     for(uint8_t i = 0; i < 5; i++)

  441.  1a6:	4e 17       	cp	r20, r30

  442.  1a8:	5f 07       	cpc	r21, r31

  443.  1aa:	19 f0       	breq	.+6      	; 0x1b2 <u8ReadSensor+0xb6>

  444.  1ac:	88 e0       	ldi	r24, 0x08	; 8

  445.  1ae:	20 e0       	ldi	r18, 0x00	; 0

  446.  1b0:	e2 cf       	rjmp	.-60     	; 0x176 <u8ReadSensor+0x7a>

  447. 

  448.         sensor_data[i] = sensor_byte;

  449.     }

  450. 

  451.     // checksum

  452.     if ( ((sensor_data[0] + sensor_data[1] + sensor_data[2] + sensor_data[3]) & 0xff ) != sensor_data[4])

  453.  1b2:	a9 81       	ldd	r26, Y+1	; 0x01

  454.  1b4:	b0 e0       	ldi	r27, 0x00	; 0

  455.  1b6:	ea 81       	ldd	r30, Y+2	; 0x02

  456.  1b8:	f0 e0       	ldi	r31, 0x00	; 0

  457.  1ba:	6b 81       	ldd	r22, Y+3	; 0x03

  458.  1bc:	70 e0       	ldi	r23, 0x00	; 0

  459.  1be:	4c 81       	ldd	r20, Y+4	; 0x04

  460.  1c0:	50 e0       	ldi	r21, 0x00	; 0

  461.  1c2:	9d 01       	movw	r18, r26

  462.  1c4:	2e 0f       	add	r18, r30

  463.  1c6:	3f 1f       	adc	r19, r31

  464.  1c8:	26 0f       	add	r18, r22

  465.  1ca:	37 1f       	adc	r19, r23

  466.  1cc:	24 0f       	add	r18, r20

  467.  1ce:	35 1f       	adc	r19, r21

  468.  1d0:	33 27       	eor	r19, r19

  469.  1d2:	0d 81       	ldd	r16, Y+5	; 0x05

  470.  1d4:	10 e0       	ldi	r17, 0x00	; 0

  471.  1d6:	20 17       	cp	r18, r16

  472.  1d8:	31 07       	cpc	r19, r17

  473.  1da:	d9 f4       	brne	.+54     	; 0x212 <u8ReadSensor+0x116>

  474.         // debug output

  475.         //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 ));

  476.         return 7;

  477.     }

  478. 

  479.     g_u16Humidity = (sensor_data[0] << 8) + sensor_data[1];

  480.  1dc:	ba 2f       	mov	r27, r26

  481.  1de:	aa 27       	eor	r26, r26

  482.  1e0:	ea 0f       	add	r30, r26

  483.  1e2:	fb 1f       	adc	r31, r27

  484.  1e4:	f0 93 11 01 	sts	0x0111, r31	; 0x800111 <g_u16Humidity+0x1>

  485.  1e8:	e0 93 10 01 	sts	0x0110, r30	; 0x800110 <g_u16Humidity>

  486.     g_u16Temperature = (sensor_data[2] << 8) + sensor_data[3];

  487.  1ec:	76 2f       	mov	r23, r22

  488.  1ee:	66 27       	eor	r22, r22

  489.  1f0:	46 0f       	add	r20, r22

  490.  1f2:	57 1f       	adc	r21, r23

  491.  1f4:	50 93 0f 01 	sts	0x010F, r21	; 0x80010f <__data_end+0x1>

  492.  1f8:	40 93 0e 01 	sts	0x010E, r20	; 0x80010e <__data_end>

  493. 

  494.     return 0;

  495.  1fc:	0b c0       	rjmp	.+22     	; 0x214 <u8ReadSensor+0x118>

  496.     while ( SENSOR_is_hi )

  497.     {

  498.         _delay_us(1);

  499.         if ( !timeout-- )

  500.         {

  501.             return 2;

  502.  1fe:	82 e0       	ldi	r24, 0x02	; 2

  503.  200:	09 c0       	rjmp	.+18     	; 0x214 <u8ReadSensor+0x118>

  504.     while(SENSOR_is_low)

  505.     {

  506.         _delay_us(1);

  507.         if (!timeout--)

  508.         {

  509.             return 3;

  510.  202:	83 e0       	ldi	r24, 0x03	; 3

  511.  204:	07 c0       	rjmp	.+14     	; 0x214 <u8ReadSensor+0x118>

  512.     while(SENSOR_is_hi)

  513.     {

  514.         _delay_us(1);

  515.         if (!timeout--)

  516.         {

  517.             return 4;

  518.  206:	84 e0       	ldi	r24, 0x04	; 4

  519.  208:	05 c0       	rjmp	.+10     	; 0x214 <u8ReadSensor+0x118>

  520.                 _delay_us(1);

  521. 

  522.                 // if timeout == 0 => sensor do not response

  523.                 if (!timeout--)

  524.                 {

  525.                     return 5;

  526.  20a:	85 e0       	ldi	r24, 0x05	; 5

  527.  20c:	03 c0       	rjmp	.+6      	; 0x214 <u8ReadSensor+0x118>

  528.                 {

  529.                     _delay_us(1);

  530.                 

  531.                     if (!timeout--)

  532.                     {

  533.                         return 6;

  534.  20e:	86 e0       	ldi	r24, 0x06	; 6

  535.  210:	01 c0       	rjmp	.+2      	; 0x214 <u8ReadSensor+0x118>

  536.     // checksum

  537.     if ( ((sensor_data[0] + sensor_data[1] + sensor_data[2] + sensor_data[3]) & 0xff ) != sensor_data[4])

  538.     {

  539.         // debug output

  540.         //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 ));

  541.         return 7;

  542.  212:	87 e0       	ldi	r24, 0x07	; 7

  543. 

  544.     g_u16Humidity = (sensor_data[0] << 8) + sensor_data[1];

  545.     g_u16Temperature = (sensor_data[2] << 8) + sensor_data[3];

  546. 

  547.     return 0;

  548.  214:	0f 90       	pop	r0

  549.  216:	0f 90       	pop	r0

  550.  218:	0f 90       	pop	r0

  551.  21a:	0f 90       	pop	r0

  552.  21c:	0f 90       	pop	r0

  553.  21e:	df 91       	pop	r29

  554.  220:	cf 91       	pop	r28

  555.  222:	1f 91       	pop	r17

  556.  224:	0f 91       	pop	r16

  557.  226:	08 95       	ret

  558. 

  559. 00000228 <main>:

  560. int main(void)

  561. {

  562.     uint16_t u16Counter = 0U;

  563.     uint8_t u8ErrorCode = 0U;

  564. 

  565.     vInit();

  566.  228:	21 df       	rcall	.-446    	; 0x6c <vInit>

  567.     

  568.     g_u8Tens = 10; //n

  569.  22a:	8a e0       	ldi	r24, 0x0A	; 10

  570.  22c:	80 93 13 01 	sts	0x0113, r24	; 0x800113 <g_u8Tens>

  571.     g_u8Ones = 11; //o

  572.  230:	8b e0       	ldi	r24, 0x0B	; 11

  573.  232:	80 93 12 01 	sts	0x0112, r24	; 0x800112 <g_u8Ones>

  574. /************************************************************************/

  575. /* main()                                                               */

  576. /************************************************************************/

  577. int main(void)

  578. {

  579.     uint16_t u16Counter = 0U;

  580.  236:	c0 e0       	ldi	r28, 0x00	; 0

  581.  238:	d0 e0       	ldi	r29, 0x00	; 0

  582.                     //g_u8Tens = g_u16Temperature / 10U;

  583.                     //g_u8Ones = g_u16Temperature - (g_u8Tens * 10U);

  584.                 }

  585.                 else

  586.                 {

  587.                     g_u8Tens = 12;

  588.  23a:	1c e0       	ldi	r17, 0x0C	; 12

  589.  23c:	3a c0       	rjmp	.+116    	; 0x2b2 <main+0x8a>

  590. 

  591.     while ( 1 )

  592.     {

  593.         if ( u16Counter > 1000 )

  594.         {

  595.             if ( SENSOR_is_hi )

  596.  23e:	33 9b       	sbis	0x06, 3	; 6

  597.  240:	02 c0       	rjmp	.+4      	; 0x246 <main+0x1e>

  598.             {

  599.                 SENSOR_sda_out;

  600.  242:	3b 9a       	sbi	0x07, 3	; 7

  601.                 SENSOR_sda_low;

  602.  244:	43 98       	cbi	0x08, 3	; 8

  603.             }

  604.             if ( u16Counter > 1005 )

  605.  246:	ce 3e       	cpi	r28, 0xEE	; 238

  606.  248:	83 e0       	ldi	r24, 0x03	; 3

  607.  24a:	d8 07       	cpc	r29, r24

  608.  24c:	90 f1       	brcs	.+100    	; 0x2b2 <main+0x8a>

  609.             {

  610.                 //_delay_us(1200);

  611.                 //_delay_ms(20);	// start signal (pull sda down for min 0.8ms and maximum 20ms)

  612.                 u8ErrorCode = u8ReadSensor();

  613.  24e:	56 df       	rcall	.-340    	; 0xfc <u8ReadSensor>

  614.                 if ( 0 == u8ErrorCode )

  615.  250:	81 11       	cpse	r24, r1

  616.  252:	29 c0       	rjmp	.+82     	; 0x2a6 <main+0x7e>

  617.                 {

  618.                     g_u16Humidity /= 10;

  619.  254:	e0 91 10 01 	lds	r30, 0x0110	; 0x800110 <g_u16Humidity>

  620.  258:	f0 91 11 01 	lds	r31, 0x0111	; 0x800111 <g_u16Humidity+0x1>

  621.  25c:	9f 01       	movw	r18, r30

  622.  25e:	ad ec       	ldi	r26, 0xCD	; 205

  623.  260:	bc ec       	ldi	r27, 0xCC	; 204

  624.  262:	2f d0       	rcall	.+94     	; 0x2c2 <__umulhisi3>

  625.  264:	ac 01       	movw	r20, r24

  626.  266:	56 95       	lsr	r21

  627.  268:	47 95       	ror	r20

  628.  26a:	56 95       	lsr	r21

  629.  26c:	47 95       	ror	r20

  630.  26e:	56 95       	lsr	r21

  631.  270:	47 95       	ror	r20

  632.  272:	50 93 11 01 	sts	0x0111, r21	; 0x800111 <g_u16Humidity+0x1>

  633.  276:	40 93 10 01 	sts	0x0110, r20	; 0x800110 <g_u16Humidity>

  634.                     g_u8Tens = g_u16Humidity / 10U;

  635.  27a:	36 95       	lsr	r19

  636.  27c:	27 95       	ror	r18

  637.  27e:	36 95       	lsr	r19

  638.  280:	27 95       	ror	r18

  639.  282:	ab e7       	ldi	r26, 0x7B	; 123

  640.  284:	b4 e1       	ldi	r27, 0x14	; 20

  641.  286:	1d d0       	rcall	.+58     	; 0x2c2 <__umulhisi3>

  642.  288:	96 95       	lsr	r25

  643.  28a:	87 95       	ror	r24

  644.  28c:	80 93 13 01 	sts	0x0113, r24	; 0x800113 <g_u8Tens>

  645.                     g_u8Ones = g_u16Humidity - (g_u8Tens * 10U);

  646.  290:	88 0f       	add	r24, r24

  647.  292:	98 2f       	mov	r25, r24

  648.  294:	99 0f       	add	r25, r25

  649.  296:	99 0f       	add	r25, r25

  650.  298:	89 0f       	add	r24, r25

  651.  29a:	48 1b       	sub	r20, r24

  652.  29c:	40 93 12 01 	sts	0x0112, r20	; 0x800112 <g_u8Ones>

  653.                 else

  654.                 {

  655.                     g_u8Tens = 12;

  656.                     g_u8Ones = u8ErrorCode;

  657.                 }

  658.                 u16Counter = 0U;

  659.  2a0:	c0 e0       	ldi	r28, 0x00	; 0

  660.  2a2:	d0 e0       	ldi	r29, 0x00	; 0

  661.  2a4:	06 c0       	rjmp	.+12     	; 0x2b2 <main+0x8a>

  662.                     //g_u8Tens = g_u16Temperature / 10U;

  663.                     //g_u8Ones = g_u16Temperature - (g_u8Tens * 10U);

  664.                 }

  665.                 else

  666.                 {

  667.                     g_u8Tens = 12;

  668.  2a6:	10 93 13 01 	sts	0x0113, r17	; 0x800113 <g_u8Tens>

  669.                     g_u8Ones = u8ErrorCode;

  670.  2aa:	80 93 12 01 	sts	0x0112, r24	; 0x800112 <g_u8Ones>

  671.                 }

  672.                 u16Counter = 0U;

  673.  2ae:	c0 e0       	ldi	r28, 0x00	; 0

  674.  2b0:	d0 e0       	ldi	r29, 0x00	; 0

  675.              }

  676.         }

  677.         u16Counter++;

  678.  2b2:	21 96       	adiw	r28, 0x01	; 1

  679.         

  680.         //vReadButtons();

  681.         //vCalculate();

  682.         vShow();

  683.  2b4:	eb de       	rcall	.-554    	; 0x8c <vShow>

  684.     g_u8Tens = 10; //n

  685.     g_u8Ones = 11; //o

  686. 

  687.     while ( 1 )

  688.     {

  689.         if ( u16Counter > 1000 )

  690.  2b6:	c9 3e       	cpi	r28, 0xE9	; 233

  691.  2b8:	83 e0       	ldi	r24, 0x03	; 3

  692.  2ba:	d8 07       	cpc	r29, r24

  693.  2bc:	08 f0       	brcs	.+2      	; 0x2c0 <main+0x98>

  694.  2be:	bf cf       	rjmp	.-130    	; 0x23e <main+0x16>

  695.  2c0:	f8 cf       	rjmp	.-16     	; 0x2b2 <main+0x8a>

  696. 

  697. 000002c2 <__umulhisi3>:

  698.  2c2:	a2 9f       	mul	r26, r18

  699.  2c4:	b0 01       	movw	r22, r0

  700.  2c6:	b3 9f       	mul	r27, r19

  701.  2c8:	c0 01       	movw	r24, r0

  702.  2ca:	a3 9f       	mul	r26, r19

  703.  2cc:	01 d0       	rcall	.+2      	; 0x2d0 <__umulhisi3+0xe>

  704.  2ce:	b2 9f       	mul	r27, r18

  705.  2d0:	70 0d       	add	r23, r0

  706.  2d2:	81 1d       	adc	r24, r1

  707.  2d4:	11 24       	eor	r1, r1

  708.  2d6:	91 1d       	adc	r25, r1

  709.  2d8:	08 95       	ret

  710. 

  711. 000002da <_exit>:

  712.  2da:	f8 94       	cli

  713. 

  714. 000002dc <__stop_program>:

  715.  2dc:	ff cf       	rjmp	.-2      	; 0x2dc <__stop_program>