📄 main.lss

📁 DS18B20最全驱动.包含CRC8算法.ROM Search等.主机采用AVR mega16或者mega32.原创作品.
💻 LSS
📖 第 1 页 / 共 5 页
字号:
12 3 4 5 下一页

main.elf:     file format elf32-avr

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .text         00000f78  00000000  00000000  00000074  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  1 .data         00000076  00800060  00000f78  00000fec  2**0
                  CONTENTS, ALLOC, LOAD, DATA
  2 .bss          00000143  008000d6  00000fee  00001062  2**0
                  ALLOC
  3 .debug_aranges 00000080  00000000  00000000  00001062  2**0
                  CONTENTS, READONLY, DEBUGGING
  4 .debug_pubnames 00000363  00000000  00000000  000010e2  2**0
                  CONTENTS, READONLY, DEBUGGING
  5 .debug_info   00000b33  00000000  00000000  00001445  2**0
                  CONTENTS, READONLY, DEBUGGING
  6 .debug_abbrev 00000397  00000000  00000000  00001f78  2**0
                  CONTENTS, READONLY, DEBUGGING
  7 .debug_line   0000092a  00000000  00000000  0000230f  2**0
                  CONTENTS, READONLY, DEBUGGING
  8 .debug_frame  00000160  00000000  00000000  00002c3c  2**2
                  CONTENTS, READONLY, DEBUGGING
  9 .debug_str    000003b7  00000000  00000000  00002d9c  2**0
                  CONTENTS, READONLY, DEBUGGING
 10 .debug_loc    000001eb  00000000  00000000  00003153  2**0
                  CONTENTS, READONLY, DEBUGGING
 11 .debug_ranges 000000c0  00000000  00000000  0000333e  2**0
                  CONTENTS, READONLY, DEBUGGING
Disassembly of section .text:

00000000 <__vectors>:
   0:	0c 94 aa 00 	jmp	0x154	; 0x154 <__ctors_end>
   4:	0c 94 c7 00 	jmp	0x18e	; 0x18e <__bad_interrupt>
   8:	0c 94 c7 00 	jmp	0x18e	; 0x18e <__bad_interrupt>
   c:	0c 94 c7 00 	jmp	0x18e	; 0x18e <__bad_interrupt>
  10:	0c 94 c7 00 	jmp	0x18e	; 0x18e <__bad_interrupt>
  14:	0c 94 c7 00 	jmp	0x18e	; 0x18e <__bad_interrupt>
  18:	0c 94 c7 00 	jmp	0x18e	; 0x18e <__bad_interrupt>
  1c:	0c 94 c7 00 	jmp	0x18e	; 0x18e <__bad_interrupt>
  20:	0c 94 c7 00 	jmp	0x18e	; 0x18e <__bad_interrupt>
  24:	0c 94 c7 00 	jmp	0x18e	; 0x18e <__bad_interrupt>
  28:	0c 94 7c 03 	jmp	0x6f8	; 0x6f8 <__vector_10>
  2c:	0c 94 c7 00 	jmp	0x18e	; 0x18e <__bad_interrupt>
  30:	0c 94 c7 00 	jmp	0x18e	; 0x18e <__bad_interrupt>
  34:	0c 94 8f 04 	jmp	0x91e	; 0x91e <__vector_13>
  38:	0c 94 c7 00 	jmp	0x18e	; 0x18e <__bad_interrupt>
  3c:	0c 94 50 04 	jmp	0x8a0	; 0x8a0 <__vector_15>
  40:	0c 94 c7 00 	jmp	0x18e	; 0x18e <__bad_interrupt>
  44:	0c 94 c7 00 	jmp	0x18e	; 0x18e <__bad_interrupt>
  48:	0c 94 c7 00 	jmp	0x18e	; 0x18e <__bad_interrupt>
  4c:	0c 94 c7 00 	jmp	0x18e	; 0x18e <__bad_interrupt>
  50:	0c 94 c7 00 	jmp	0x18e	; 0x18e <__bad_interrupt>

00000054 <Crc8Table>:
  54:	00 5e bc e2 61 3f dd 83 c2 9c 7e 20 a3 fd 1f 41     .^..a?....~ ...A
  64:	9d c3 21 7f fc a2 40 1e 5f 01 e3 bd 3e 60 82 dc     ..!...@._...>`..
  74:	23 7d 9f c1 42 1c fe a0 e1 bf 5d 03 80 de 3c 62     #}..B.....]...<b
  84:	be e0 02 5c df 81 63 3d 7c 22 c0 9e 1d 43 a1 ff     ...\..c=|"...C..
  94:	46 18 fa a4 27 79 9b c5 84 da 38 66 e5 bb 59 07     F...'y....8f..Y.
  a4:	db 85 67 39 ba e4 06 58 19 47 a5 fb 78 26 c4 9a     ..g9...X.G..x&..
  b4:	65 3b d9 87 04 5a b8 e6 a7 f9 1b 45 c6 98 7a 24     e;...Z.....E..z$
  c4:	f8 a6 44 1a 99 c7 25 7b 3a 64 86 d8 5b 05 e7 b9     ..D...%{:d..[...
  d4:	8c d2 30 6e ed b3 51 0f 4e 10 f2 ac 2f 71 93 cd     ..0n..Q.N.../q..
  e4:	11 4f ad f3 70 2e cc 92 d3 8d 6f 31 b2 ec 0e 50     .O..p.....o1...P
  f4:	af f1 13 4d ce 90 72 2c 6d 33 d1 8f 0c 52 b0 ee     ...M..r,m3...R..
 104:	32 6c 8e d0 53 0d ef b1 f0 ae 4c 12 91 cf 2d 73     2l..S.....L...-s
 114:	ca 94 76 28 ab f5 17 49 08 56 b4 ea 69 37 d5 8b     ..v(...I.V..i7..
 124:	57 09 eb b5 36 68 8a d4 95 cb 29 77 f4 aa 48 16     W...6h....)w..H.
 134:	e9 b7 55 0b 88 d6 34 6a 2b 75 97 c9 4a 14 f6 a8     ..U...4j+u..J...
 144:	74 2a c8 96 15 4b a9 f7 b6 e8 0a 54 d7 89 6b 35     t*...K.....T..k5

00000154 <__ctors_end>:
 154:	11 24       	eor	r1, r1
 156:	1f be       	out	0x3f, r1	; 63
 158:	cf e5       	ldi	r28, 0x5F	; 95
 15a:	d8 e0       	ldi	r29, 0x08	; 8
 15c:	de bf       	out	0x3e, r29	; 62
 15e:	cd bf       	out	0x3d, r28	; 61

00000160 <__do_copy_data>:
 160:	10 e0       	ldi	r17, 0x00	; 0
 162:	a0 e6       	ldi	r26, 0x60	; 96
 164:	b0 e0       	ldi	r27, 0x00	; 0
 166:	e8 e7       	ldi	r30, 0x78	; 120
 168:	ff e0       	ldi	r31, 0x0F	; 15
 16a:	02 c0       	rjmp	.+4      	; 0x170 <.do_copy_data_start>

0000016c <.do_copy_data_loop>:
 16c:	05 90       	lpm	r0, Z+
 16e:	0d 92       	st	X+, r0

00000170 <.do_copy_data_start>:
 170:	a6 3d       	cpi	r26, 0xD6	; 214
 172:	b1 07       	cpc	r27, r17
 174:	d9 f7       	brne	.-10     	; 0x16c <.do_copy_data_loop>

00000176 <__do_clear_bss>:
 176:	12 e0       	ldi	r17, 0x02	; 2
 178:	a6 ed       	ldi	r26, 0xD6	; 214
 17a:	b0 e0       	ldi	r27, 0x00	; 0
 17c:	01 c0       	rjmp	.+2      	; 0x180 <.do_clear_bss_start>

0000017e <.do_clear_bss_loop>:
 17e:	1d 92       	st	X+, r1

00000180 <.do_clear_bss_start>:
 180:	a9 31       	cpi	r26, 0x19	; 25
 182:	b1 07       	cpc	r27, r17
 184:	e1 f7       	brne	.-8      	; 0x17e <.do_clear_bss_loop>
 186:	0e 94 c9 00 	call	0x192	; 0x192 <main>
 18a:	0c 94 ba 07 	jmp	0xf74	; 0xf74 <_exit>

0000018e <__bad_interrupt>:
 18e:	0c 94 00 00 	jmp	0	; 0x0 <__vectors>

00000192 <main>:
#include "system.h"


int main(void)
{
 192:	0e 94 d3 03 	call	0x7a6	; 0x7a6 <UartInit>
	
	UartInit();
	Timer0Init();
 196:	0e 94 71 03 	call	0x6e2	; 0x6e2 <Timer0Init>
//	PORTA=0x01;
//	DDRA=0x01;
	asm("sei"); 	//开全局中断 
 19a:	78 94       	sei

	UartSendString((unsigned char *)"明君电子欢迎你!\r\n");
 19c:	80 e6       	ldi	r24, 0x60	; 96
 19e:	90 e0       	ldi	r25, 0x00	; 0
 1a0:	0e 94 33 04 	call	0x866	; 0x866 <UartSendString>
	ReadTemperature();
 1a4:	0e 94 72 01 	call	0x2e4	; 0x2e4 <ReadTemperature>
	
	while(1)
	{
		UARTProcessing();
 1a8:	0e 94 b9 04 	call	0x972	; 0x972 <UARTProcessing>
 1ac:	fd cf       	rjmp	.-6      	; 0x1a8 <main+0x16>

000001ae <CRC8>:
116,42,200,150,21,75,169,247,182,232,10,84,215,137,107,53};
//#define   Crc8Table(i)		(pgm_read_byte(Crc8Table+(i)))


unsigned char CRC8(unsigned char *checkbuf,unsigned char checkbyte)
{
 1ae:	dc 01       	movw	r26, r24
 1b0:	90 e0       	ldi	r25, 0x00	; 0
 1b2:	08 c0       	rjmp	.+16     	; 0x1c4 <CRC8+0x16>
	unsigned char i;
	unsigned char crcdata;
	for(i=0;i<checkbyte;i++)
	{
		crcdata=pgm_read_byte(Crc8Table+(crcdata^(*(checkbuf+i))));
 1b4:	ed 91       	ld	r30, X+
 1b6:	e8 27       	eor	r30, r24
 1b8:	f0 e0       	ldi	r31, 0x00	; 0
 1ba:	ec 5a       	subi	r30, 0xAC	; 172
 1bc:	ff 4f       	sbci	r31, 0xFF	; 255
 1be:	e4 91       	lpm	r30, Z+

unsigned char CRC8(unsigned char *checkbuf,unsigned char checkbyte)
{
	unsigned char i;
	unsigned char crcdata;
	for(i=0;i<checkbyte;i++)
 1c0:	9f 5f       	subi	r25, 0xFF	; 255
 1c2:	8e 2f       	mov	r24, r30
 1c4:	96 17       	cp	r25, r22
 1c6:	b0 f3       	brcs	.-20     	; 0x1b4 <CRC8+0x6>
	{
		crcdata=pgm_read_byte(Crc8Table+(crcdata^(*(checkbuf+i))));
	}
    return crcdata;
}
 1c8:	08 95       	ret

000001ca <OneWireInit>:

void OneWireInit(void)		//复位
{
 1ca:	d0 9a       	sbi	0x1a, 0	; 26
	unsigned int i=0;
	OneWireDDR	|= (1<<DS18B20);
	OneWirePORT	|= (1<<DS18B20);
 1cc:	d8 9a       	sbi	0x1b, 0	; 27
	OneWirePORT	&=~(1<<DS18B20);
 1ce:	d8 98       	cbi	0x1b, 0	; 27
    milliseconds can be achieved.
 */
void
_delay_loop_2(uint16_t __count)
{
	__asm__ volatile (
 1d0:	88 e2       	ldi	r24, 0x28	; 40
 1d2:	92 e0       	ldi	r25, 0x02	; 2
 1d4:	fc 01       	movw	r30, r24
 1d6:	31 97       	sbiw	r30, 0x01	; 1
 1d8:	f1 f7       	brne	.-4      	; 0x1d6 <OneWireInit+0xc>
	_delay_us(200);			//480~960us
	_delay_us(200);
	_delay_us(200);
	_delay_us(100);
	OneWirePORT	|= (1<<DS18B20);
 1da:	fc 01       	movw	r30, r24
 1dc:	31 97       	sbiw	r30, 0x01	; 1
 1de:	f1 f7       	brne	.-4      	; 0x1dc <OneWireInit+0x12>
 1e0:	01 97       	sbiw	r24, 0x01	; 1
 1e2:	f1 f7       	brne	.-4      	; 0x1e0 <OneWireInit+0x16>
 1e4:	84 e1       	ldi	r24, 0x14	; 20
 1e6:	91 e0       	ldi	r25, 0x01	; 1
 1e8:	01 97       	sbiw	r24, 0x01	; 1
 1ea:	f1 f7       	brne	.-4      	; 0x1e8 <OneWireInit+0x1e>
 1ec:	d8 9a       	sbi	0x1b, 0	; 27
	OneWireDDR	&=~(1<<DS18B20);
 1ee:	d0 98       	cbi	0x1a, 0	; 26
 1f0:	88 ef       	ldi	r24, 0xF8	; 248
 1f2:	90 e0       	ldi	r25, 0x00	; 0
 1f4:	01 97       	sbiw	r24, 0x01	; 1
 1f6:	f1 f7       	brne	.-4      	; 0x1f4 <OneWireInit+0x2a>
 1f8:	80 e0       	ldi	r24, 0x00	; 0
 1fa:	90 e0       	ldi	r25, 0x00	; 0
 1fc:	08 c0       	rjmp	.+16     	; 0x20e <OneWireInit+0x44>
	_delay_us(90);			//15~60us
	while(OneWirePIN&(1<<DS18B20))	//注意此处如果检测不到DS18B20，那会产生温度报警，但是不能影响正常工作.
	{
		i++;
 1fe:	01 96       	adiw	r24, 0x01	; 1
		if(i>=500)					//注意此处i的大小要根据测温器件与系统的连接线的长短而定
 200:	21 e0       	ldi	r18, 0x01	; 1
 202:	84 3f       	cpi	r24, 0xF4	; 244
 204:	92 07       	cpc	r25, r18
 206:	19 f4       	brne	.+6      	; 0x20e <OneWireInit+0x44>
		{
			OneWireConnectFlag=0;
 208:	10 92 cb 00 	sts	0x00CB, r1
 20c:	08 95       	ret
	_delay_us(200);
	_delay_us(100);
	OneWirePORT	|= (1<<DS18B20);
	OneWireDDR	&=~(1<<DS18B20);
	_delay_us(90);			//15~60us
	while(OneWirePIN&(1<<DS18B20))	//注意此处如果检测不到DS18B20，那会产生温度报警，但是不能影响正常工作.
 20e:	c8 99       	sbic	0x19, 0	; 25
 210:	f6 cf       	rjmp	.-20     	; 0x1fe <OneWireInit+0x34>
		{
			OneWireConnectFlag=0;
			return;
		}
	}
	OneWireConnectFlag=1;
 212:	81 e0       	ldi	r24, 0x01	; 1
 214:	80 93 cb 00 	sts	0x00CB, r24
	OneWireDDR	|= (1<<DS18B20);
 218:	d0 9a       	sbi	0x1a, 0	; 26
	OneWirePORT	|= (1<<DS18B20);
 21a:	d8 9a       	sbi	0x1b, 0	; 27
 21c:	87 e9       	ldi	r24, 0x97	; 151
 21e:	92 e0       	ldi	r25, 0x02	; 2
 220:	01 97       	sbiw	r24, 0x01	; 1
 222:	f1 f7       	brne	.-4      	; 0x220 <OneWireInit+0x56>
 224:	08 95       	ret

00000226 <WriteOneWire>:
		OneWireID[i]=ReadOneWire();
	}
}

void WriteOneWire(unsigned char Data)	//向单总线的从机写入数据(先写低位再写高位,与SPI相反)
{
 226:	20 e0       	ldi	r18, 0x00	; 0
 228:	30 e0       	ldi	r19, 0x00	; 0
	unsigned char i;
	for(i=0;i<8;i++)
	{
		OneWirePORT&=~(1<<DS18B20);
		if(Data&(1<<i))OneWirePORT|=(1<<DS18B20);//写数据了，先写低位的！
 22a:	48 2f       	mov	r20, r24
 22c:	50 e0       	ldi	r21, 0x00	; 0
    can be achieved.
*/
void
_delay_loop_1(uint8_t __count)
{
	__asm__ volatile (
 22e:	6d ed       	ldi	r22, 0xDD	; 221
void WriteOneWire(unsigned char Data)	//向单总线的从机写入数据(先写低位再写高位,与SPI相反)
{
	unsigned char i;
	for(i=0;i<8;i++)
	{
		OneWirePORT&=~(1<<DS18B20);
 230:	d8 98       	cbi	0x1b, 0	; 27
		if(Data&(1<<i))OneWirePORT|=(1<<DS18B20);//写数据了，先写低位的！
 232:	ca 01       	movw	r24, r20
 234:	02 2e       	mov	r0, r18
 236:	02 c0       	rjmp	.+4      	; 0x23c <WriteOneWire+0x16>
 238:	95 95       	asr	r25
 23a:	87 95       	ror	r24
 23c:	0a 94       	dec	r0
 23e:	e2 f7       	brpl	.-8      	; 0x238 <WriteOneWire+0x12>
 240:	80 ff       	sbrs	r24, 0
 242:	02 c0       	rjmp	.+4      	; 0x248 <WriteOneWire+0x22>
 244:	d8 9a       	sbi	0x1b, 0	; 27
 246:	01 c0       	rjmp	.+2      	; 0x24a <WriteOneWire+0x24>
		else OneWirePORT&=~(1<<DS18B20);
 248:	d8 98       	cbi	0x1b, 0	; 27
 24a:	86 2f       	mov	r24, r22
 24c:	8a 95       	dec	r24
 24e:	f1 f7       	brne	.-4      	; 0x24c <WriteOneWire+0x26>
		_delay_us(60);			//15~60us
		OneWirePORT|=(1<<DS18B20);
 250:	d8 9a       	sbi	0x1b, 0	; 27
 252:	2f 5f       	subi	r18, 0xFF	; 255
 254:	3f 4f       	sbci	r19, 0xFF	; 255
}

void WriteOneWire(unsigned char Data)	//向单总线的从机写入数据(先写低位再写高位,与SPI相反)
{
	unsigned char i;
	for(i=0;i<8;i++)
 256:	28 30       	cpi	r18, 0x08	; 8
 258:	31 05       	cpc	r19, r1
 25a:	51 f7       	brne	.-44     	; 0x230 <WriteOneWire+0xa>
		if(Data&(1<<i))OneWirePORT|=(1<<DS18B20);//写数据了，先写低位的！
		else OneWirePORT&=~(1<<DS18B20);
		_delay_us(60);			//15~60us
		OneWirePORT|=(1<<DS18B20);
	}
	OneWirePORT|=(1<<DS18B20);
 25c:	d8 9a       	sbi	0x1b, 0	; 27
 25e:	8b e0       	ldi	r24, 0x0B	; 11
 260:	8a 95       	dec	r24
 262:	f1 f7       	brne	.-4      	; 0x260 <WriteOneWire+0x3a>
	_delay_us(3);
}
 264:	08 95       	ret

00000266 <ReadOneWire>:

unsigned char ReadOneWire(void)
{
 266:	40 e0       	ldi	r20, 0x00	; 0
 268:	20 e0       	ldi	r18, 0x00	; 0
 26a:	30 e0       	ldi	r19, 0x00	; 0
		OneWirePORT	&=~(1<<DS18B20);
		OneWirePORT	|= (1<<DS18B20);
		OneWireDDR	&=~(1<<DS18B20);
		temp=(OneWirePIN&(1<<DS18B20));		//读数据,从低位开始
		if(temp)OneWireData	|= (1<<n);
		else OneWireData	&=~(1<<n);
 26c:	61 e0       	ldi	r22, 0x01	; 1
 26e:	70 e0       	ldi	r23, 0x00	; 0
    milliseconds can be achieved.
 */
void
_delay_loop_2(uint16_t __count)
{
	__asm__ volatile (
 270:	eb e4       	ldi	r30, 0x4B	; 75
12 3 4 5 下一页
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -