⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 main.lss

📁 这是使用AVR GCC的读取DS18B20的代码。 代码功能很全
💻 LSS
📖 第 1 页 / 共 5 页
字号:
     c0c:	90 95       	com	r25
     c0e:	80 81       	ld	r24, Z
     c10:	89 23       	and	r24, r25
     c12:	80 83       	st	Z, r24
/* delay function for microsec
   4 cpu cycles per loop + 1 cycles(?) overhead 
   when a constant is passed. */
static inline void delayloop16(uint16_t count)
{
     c14:	89 e1       	ldi	r24, 0x19	; 25
     c16:	90 e0       	ldi	r25, 0x00	; 0
	asm volatile (  "cp  %A0,__zero_reg__ \n\t"  \
     c18:	81 15       	cp	r24, r1
     c1a:	91 05       	cpc	r25, r1
     c1c:	11 f0       	breq	.+4      	; 0xc22 <L_Exit_180>

00000c1e <L_LOOP_180>:
     c1e:	01 97       	sbiw	r24, 0x01	; 1
     c20:	f1 f7       	brne	.-4      	; 0xc1e <L_LOOP_180>

00000c22 <L_Exit_180>:
		
	// wuffwuff delay was 15uS-1 see comment above
	delay_us(15-1-OW_CONF_DELAYOFFSET);
		
	if( OW_GET_IN() == 0 ) b = 0;  // sample at end of read-timeslot
     c22:	e0 91 da 00 	lds	r30, 0x00DA
     c26:	f0 91 db 00 	lds	r31, 0x00DB
     c2a:	e0 81       	ld	r30, Z
     c2c:	20 91 d9 00 	lds	r18, 0x00D9
     c30:	e2 23       	and	r30, r18
     c32:	09 f4       	brne	.+2      	; 0xc36 <L_Exit_180+0x14>
     c34:	3e 2f       	mov	r19, r30
/* delay function for microsec
   4 cpu cycles per loop + 1 cycles(?) overhead 
   when a constant is passed. */
static inline void delayloop16(uint16_t count)
{
     c36:	89 e5       	ldi	r24, 0x59	; 89
     c38:	90 e0       	ldi	r25, 0x00	; 0
	asm volatile (  "cp  %A0,__zero_reg__ \n\t"  \
     c3a:	81 15       	cp	r24, r1
     c3c:	91 05       	cpc	r25, r1
     c3e:	11 f0       	breq	.+4      	; 0xc44 <L_Exit_200>

00000c40 <L_LOOP_200>:
     c40:	01 97       	sbiw	r24, 0x01	; 1
     c42:	f1 f7       	brne	.-4      	; 0xc40 <L_LOOP_200>

00000c44 <L_Exit_200>:
	
	delay_us(60-15);
	OW_DIR_IN();
     c44:	e0 91 dc 00 	lds	r30, 0x00DC
     c48:	f0 91 dd 00 	lds	r31, 0x00DD
     c4c:	20 95       	com	r18
     c4e:	80 81       	ld	r24, Z
     c50:	82 23       	and	r24, r18
     c52:	80 83       	st	Z, r24
	
	SREG=sreg; // sei();
     c54:	4f bf       	out	0x3f, r20	; 63
	
	return b;
}
     c56:	83 2f       	mov	r24, r19
     c58:	99 27       	eor	r25, r25
     c5a:	08 95       	ret

00000c5c <ow_byte_wr>:


uint8_t ow_byte_wr( uint8_t b )
{
     c5c:	1f 93       	push	r17
     c5e:	cf 93       	push	r28
     c60:	c8 2f       	mov	r28, r24
	uint8_t i = 8, j;
     c62:	18 e0       	ldi	r17, 0x08	; 8
	
	do {
		j = ow_bit_io( b & 1 );
     c64:	8c 2f       	mov	r24, r28
     c66:	81 70       	andi	r24, 0x01	; 1
     c68:	0e 94 eb 05 	call	0xbd6 <ow_bit_io>
		b >>= 1;
     c6c:	c6 95       	lsr	r28
		if( j ) b |= 0x80;
     c6e:	81 11       	cpse	r24, r1
     c70:	c0 68       	ori	r28, 0x80	; 128
	} while( --i );
     c72:	11 50       	subi	r17, 0x01	; 1
     c74:	b9 f7       	brne	.-18     	; 0xc64 <ow_byte_wr+0x8>
	
	return b;
}
     c76:	8c 2f       	mov	r24, r28
     c78:	99 27       	eor	r25, r25
     c7a:	cf 91       	pop	r28
     c7c:	1f 91       	pop	r17
     c7e:	08 95       	ret

00000c80 <ow_byte_rd>:


uint8_t ow_byte_rd( void )
{
  // read by sending 0xff (a dontcare?)
  return ow_byte_wr( 0xFF ); 
     c80:	8f ef       	ldi	r24, 0xFF	; 255
     c82:	0e 94 2e 06 	call	0xc5c <ow_byte_wr>
}
     c86:	99 27       	eor	r25, r25
     c88:	08 95       	ret

00000c8a <ow_rom_search>:


uint8_t ow_rom_search( uint8_t diff, uint8_t *id )
{
     c8a:	df 92       	push	r13
     c8c:	ef 92       	push	r14
     c8e:	ff 92       	push	r15
     c90:	0f 93       	push	r16
     c92:	1f 93       	push	r17
     c94:	cf 93       	push	r28
     c96:	df 93       	push	r29
     c98:	e8 2e       	mov	r14, r24
     c9a:	eb 01       	movw	r28, r22
	uint8_t i, j, next_diff;
	uint8_t b;
	
	if( ow_reset() ) return OW_PRESENCE_ERR;	// error, no device found
     c9c:	0e 94 5d 05 	call	0xaba <ow_reset>
     ca0:	18 2f       	mov	r17, r24
     ca2:	88 23       	and	r24, r24
     ca4:	19 f0       	breq	.+6      	; 0xcac <ow_rom_search+0x22>
     ca6:	8f ef       	ldi	r24, 0xFF	; 255
     ca8:	90 e0       	ldi	r25, 0x00	; 0
     caa:	32 c0       	rjmp	.+100    	; 0xd10 <ow_rom_search+0x86>
	
	ow_byte_wr( OW_SEARCH_ROM );			// ROM search command
     cac:	80 ef       	ldi	r24, 0xF0	; 240
     cae:	0e 94 2e 06 	call	0xc5c <ow_byte_wr>
	next_diff = OW_LAST_DEVICE;			// unchanged on last device
     cb2:	d1 2e       	mov	r13, r17
	
	i = OW_ROMCODE_SIZE * 8;					// 8 bytes
     cb4:	00 e4       	ldi	r16, 0x40	; 64
	
	do {
		j = 8;					// 8 bits
     cb6:	88 e0       	ldi	r24, 0x08	; 8
     cb8:	f8 2e       	mov	r15, r24
		do {
			b = ow_bit_io( 1 );			// read bit
     cba:	81 e0       	ldi	r24, 0x01	; 1
     cbc:	0e 94 eb 05 	call	0xbd6 <ow_bit_io>
     cc0:	18 2f       	mov	r17, r24
			if( ow_bit_io( 1 ) ) {			// read complement bit
     cc2:	81 e0       	ldi	r24, 0x01	; 1
     cc4:	0e 94 eb 05 	call	0xbd6 <ow_bit_io>
     cc8:	88 23       	and	r24, r24
     cca:	29 f0       	breq	.+10     	; 0xcd6 <ow_rom_search+0x4c>
				if( b )					// 11
     ccc:	11 23       	and	r17, r17
     cce:	71 f0       	breq	.+28     	; 0xcec <ow_rom_search+0x62>
				return OW_DATA_ERR;			// data error
     cd0:	8e ef       	ldi	r24, 0xFE	; 254
     cd2:	90 e0       	ldi	r25, 0x00	; 0
     cd4:	1d c0       	rjmp	.+58     	; 0xd10 <ow_rom_search+0x86>
			}
			else {
				if( !b ) {				// 00 = 2 devices
     cd6:	11 23       	and	r17, r17
     cd8:	49 f4       	brne	.+18     	; 0xcec <ow_rom_search+0x62>
					if( diff > i || ((*id & 1) && diff != i) ) {
     cda:	0e 15       	cp	r16, r14
     cdc:	28 f0       	brcs	.+10     	; 0xce8 <ow_rom_search+0x5e>
     cde:	88 81       	ld	r24, Y
     ce0:	80 ff       	sbrs	r24, 0
     ce2:	04 c0       	rjmp	.+8      	; 0xcec <ow_rom_search+0x62>
     ce4:	e0 16       	cp	r14, r16
     ce6:	11 f0       	breq	.+4      	; 0xcec <ow_rom_search+0x62>
					b = 1;				// now 1
     ce8:	11 e0       	ldi	r17, 0x01	; 1
					next_diff = i;			// next pass 0
     cea:	d0 2e       	mov	r13, r16
					}
				}
			}
			ow_bit_io( b );     			// write bit
     cec:	81 2f       	mov	r24, r17
     cee:	0e 94 eb 05 	call	0xbd6 <ow_bit_io>
			*id >>= 1;
     cf2:	88 81       	ld	r24, Y
     cf4:	86 95       	lsr	r24
     cf6:	88 83       	st	Y, r24
			if( b ) *id |= 0x80;			// store bit
     cf8:	11 23       	and	r17, r17
     cfa:	11 f0       	breq	.+4      	; 0xd00 <ow_rom_search+0x76>
     cfc:	80 68       	ori	r24, 0x80	; 128
     cfe:	88 83       	st	Y, r24
			
			i--;
     d00:	01 50       	subi	r16, 0x01	; 1
			
		} while( --j );
     d02:	fa 94       	dec	r15
     d04:	d1 f6       	brne	.-76     	; 0xcba <ow_rom_search+0x30>
		
		id++;					// next byte
     d06:	21 96       	adiw	r28, 0x01	; 1
	
	} while( i );
     d08:	00 23       	and	r16, r16
     d0a:	a9 f6       	brne	.-86     	; 0xcb6 <ow_rom_search+0x2c>
	
	return next_diff;				// to continue search
     d0c:	8d 2d       	mov	r24, r13
     d0e:	99 27       	eor	r25, r25
     d10:	df 91       	pop	r29
     d12:	cf 91       	pop	r28
     d14:	1f 91       	pop	r17
     d16:	0f 91       	pop	r16
     d18:	ff 90       	pop	r15
     d1a:	ef 90       	pop	r14
     d1c:	df 90       	pop	r13
     d1e:	08 95       	ret

00000d20 <ow_command>:
}


void ow_command( uint8_t command, uint8_t *id )
{
     d20:	0f 93       	push	r16
     d22:	1f 93       	push	r17
     d24:	cf 93       	push	r28
     d26:	df 93       	push	r29
     d28:	08 2f       	mov	r16, r24
     d2a:	eb 01       	movw	r28, r22
	uint8_t i;

	ow_reset();
     d2c:	0e 94 5d 05 	call	0xaba <ow_reset>

	if( id ) {
     d30:	20 97       	sbiw	r28, 0x00	; 0
     d32:	51 f0       	breq	.+20     	; 0xd48 <ow_command+0x28>
		ow_byte_wr( OW_MATCH_ROM );			// to a single device
     d34:	85 e5       	ldi	r24, 0x55	; 85
     d36:	0e 94 2e 06 	call	0xc5c <ow_byte_wr>
		i = OW_ROMCODE_SIZE;
     d3a:	18 e0       	ldi	r17, 0x08	; 8
		do {
			ow_byte_wr( *id );
     d3c:	89 91       	ld	r24, Y+
     d3e:	0e 94 2e 06 	call	0xc5c <ow_byte_wr>
			id++;
		} while( --i );
     d42:	11 50       	subi	r17, 0x01	; 1
     d44:	d9 f7       	brne	.-10     	; 0xd3c <ow_command+0x1c>
     d46:	03 c0       	rjmp	.+6      	; 0xd4e <ow_command+0x2e>
	} 
	else {
		ow_byte_wr( OW_SKIP_ROM );			// to all devices
     d48:	8c ec       	ldi	r24, 0xCC	; 204
     d4a:	0e 94 2e 06 	call	0xc5c <ow_byte_wr>
	}
	
	ow_byte_wr( command );
     d4e:	80 2f       	mov	r24, r16
     d50:	0e 94 2e 06 	call	0xc5c <ow_byte_wr>
     d54:	df 91       	pop	r29
     d56:	cf 91       	pop	r28
     d58:	1f 91       	pop	r17
     d5a:	0f 91       	pop	r16
     d5c:	08 95       	ret

00000d5e <delayloop32>:

#include "delay.h"

void delayloop32(uint32_t loops) 
{
     d5e:	dc 01       	movw	r26, r24
     d60:	cb 01       	movw	r24, r22
  __asm__ volatile ( "cp  %A0,__zero_reg__ \n\t"  \
     d62:	81 15       	cp	r24, r1
     d64:	91 05       	cpc	r25, r1
     d66:	a1 05       	cpc	r26, r1
     d68:	b1 05       	cpc	r27, r1
     d6a:	29 f0       	breq	.+10     	; 0xd76 <L_Exit_5>

00000d6c <L_LOOP_5>:
     d6c:	81 50       	subi	r24, 0x01	; 1
     d6e:	90 40       	sbci	r25, 0x00	; 0
     d70:	a0 40       	sbci	r26, 0x00	; 0
     d72:	b0 40       	sbci	r27, 0x00	; 0
     d74:	d9 f7       	brne	.-10     	; 0xd6c <L_LOOP_5>

00000d76 <L_Exit_5>:
     d76:	08 95       	ret

00000d78 <DS18X20_uart_put_temp>:
#include "uart.h"

void DS18X20_uart_put_temp(const uint8_t subzero, 
	const uint8_t cel, 	const uint8_t cel_frac_bits)
{
     d78:	ef 92       	push	r14
     d7a:	ff 92       	push	r15
     d7c:	0f 93       	push	r16
     d7e:	1f 93       	push	r17
     d80:	cf 93       	push	r28
     d82:	df 93       	push	r29
     d84:	cd b7       	in	r28, 0x3d	; 61
     d86:	de b7       	in	r29, 0x3e	; 62
     d88:	61 97       	sbiw	r28, 0x11	; 17
     d8a:	0f b6       	in	r0, 0x3f	; 63
     d8c:	f8 94       	cli
     d8e:	de bf       	out	0x3e, r29	; 62
     d90:	0f be       	out	0x3f, r0	; 63
     d92:	cd bf       	out	0x3d, r28	; 61
     d94:	16 2f       	mov	r17, r22
     d96:	04 2f       	mov	r16, r20
	uint8_t buffer[sizeof(int)*8+1];
	int i;
	
	uart_putc((subzero)?'-':'+');
     d98:	88 23       	and	r24, r24
     d9a:	11 f0       	breq	.+4      	; 0xda0 <DS18X20_uart_put_temp+0x28>
     d9c:	8d e2       	ldi	r24, 0x2D	; 45
     d9e:	01 c0       	rjmp	.+2      	; 0xda2 <DS18X20_uart_put_temp+0x2a>
     da0:	8b e2       	ldi	r24, 0x2B	; 43
     da2:	0e 94 6d 0b 	call	0x16da <uart_putc>
	uart_puti((int)cel);
     da6:	81 2f       	mov	r24, r17
     da8:	99 27       	eor	r25, r25
     daa:	0e 94 a0 0b 	call	0x1740 <uart_puti>
	uart_puts_P(".");
     dae:	8e ed       	ldi	r24, 0xDE	; 222
     db0:	93 e0       	ldi	r25, 0x03	; 3
     db2:	0e 94 8e 0b 	call	0x171c <uart_puts_p>
	itoa(cel_frac_bits*DS18X20_FRACCONV,buffer,10);
     db6:	20 2f       	mov	r18, r16
     db8:	33 27       	eor	r19, r19
     dba:	4a e0       	ldi	r20, 0x0A	; 10
     dbc:	50 e0       	ldi	r21, 0x00	; 0
     dbe:	be 01       	movw	r22, r28
     dc0:	6f 5f       	subi	r22, 0xFF	; 255
     dc2:	7f 4f    

⌨️ 快捷键说明

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