📄 m16_ad.lss

📁 AVR单片机ATmega16的AD功能测试程序
💻 LSS
📖 第 1 页 / 共 2 页
字号:
12 下一页

M16_AD.elf:     file format elf32-avr

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .text         000004f4  00000000  00000000  00000094  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  1 .data         00000014  00800060  000004f4  00000588  2**0
                  CONTENTS, ALLOC, LOAD, DATA
  2 .bss          00000014  00800074  00800074  0000059c  2**0
                  ALLOC
  3 .debug_aranges 00000020  00000000  00000000  0000059c  2**0
                  CONTENTS, READONLY, DEBUGGING
  4 .debug_pubnames 0000006d  00000000  00000000  000005bc  2**0
                  CONTENTS, READONLY, DEBUGGING
  5 .debug_info   000003b2  00000000  00000000  00000629  2**0
                  CONTENTS, READONLY, DEBUGGING
  6 .debug_abbrev 000001c7  00000000  00000000  000009db  2**0
                  CONTENTS, READONLY, DEBUGGING
  7 .debug_line   0000033e  00000000  00000000  00000ba2  2**0
                  CONTENTS, READONLY, DEBUGGING
  8 .debug_frame  00000060  00000000  00000000  00000ee0  2**2
                  CONTENTS, READONLY, DEBUGGING
  9 .debug_str    0000011b  00000000  00000000  00000f40  2**0
                  CONTENTS, READONLY, DEBUGGING
 10 .debug_loc    00000249  00000000  00000000  0000105b  2**0
                  CONTENTS, READONLY, DEBUGGING
 11 .debug_ranges 000000c0  00000000  00000000  000012a4  2**0
                  CONTENTS, READONLY, DEBUGGING

Disassembly of section .text:

00000000 <__vectors>:
   0:	0c 94 2a 00 	jmp	0x54	; 0x54 <__ctors_end>
   4:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
   8:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
   c:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  10:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  14:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  18:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  1c:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  20:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  24:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  28:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  2c:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  30:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  34:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  38:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  3c:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  40:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  44:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  48:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  4c:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>
  50:	0c 94 47 00 	jmp	0x8e	; 0x8e <__bad_interrupt>

00000054 <__ctors_end>:
  54:	11 24       	eor	r1, r1
  56:	1f be       	out	0x3f, r1	; 63
  58:	cf e5       	ldi	r28, 0x5F	; 95
  5a:	d4 e0       	ldi	r29, 0x04	; 4
  5c:	de bf       	out	0x3e, r29	; 62
  5e:	cd bf       	out	0x3d, r28	; 61

00000060 <__do_copy_data>:
  60:	10 e0       	ldi	r17, 0x00	; 0
  62:	a0 e6       	ldi	r26, 0x60	; 96
  64:	b0 e0       	ldi	r27, 0x00	; 0
  66:	e4 ef       	ldi	r30, 0xF4	; 244
  68:	f4 e0       	ldi	r31, 0x04	; 4
  6a:	02 c0       	rjmp	.+4      	; 0x70 <.do_copy_data_start>

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

00000070 <.do_copy_data_start>:
  70:	a4 37       	cpi	r26, 0x74	; 116
  72:	b1 07       	cpc	r27, r17
  74:	d9 f7       	brne	.-10     	; 0x6c <.do_copy_data_loop>

00000076 <__do_clear_bss>:
  76:	10 e0       	ldi	r17, 0x00	; 0
  78:	a4 e7       	ldi	r26, 0x74	; 116
  7a:	b0 e0       	ldi	r27, 0x00	; 0
  7c:	01 c0       	rjmp	.+2      	; 0x80 <.do_clear_bss_start>

0000007e <.do_clear_bss_loop>:
  7e:	1d 92       	st	X+, r1

00000080 <.do_clear_bss_start>:
  80:	a8 38       	cpi	r26, 0x88	; 136
  82:	b1 07       	cpc	r27, r17
  84:	e1 f7       	brne	.-8      	; 0x7e <.do_clear_bss_loop>
  86:	0e 94 03 01 	call	0x206	; 0x206 <main>
  8a:	0c 94 78 02 	jmp	0x4f0	; 0x4f0 <_exit>

0000008e <__bad_interrupt>:
  8e:	0c 94 00 00 	jmp	0	; 0x0 <__vectors>

00000092 <DelayMs>:
	for(;i!=0;i--)
	{
		for(j=250;j!=0;j--) 
		{;}
	}
}
  92:	08 95       	ret

00000094 <Display>:

void Display(uint8_t *p)              //间隔5ms显示
{
  94:	bc 01       	movw	r22, r24
  96:	41 e0       	ldi	r20, 0x01	; 1
  98:	20 e0       	ldi	r18, 0x00	; 0
  9a:	30 e0       	ldi	r19, 0x00	; 0
    milliseconds can be achieved.
 */
void
_delay_loop_2(uint16_t __count)
{
	__asm__ volatile (
  9c:	a0 e0       	ldi	r26, 0x00	; 0
  9e:	b8 e4       	ldi	r27, 0x48	; 72
	uint8_t i,sel=0x01;
 	for(i=0;i<4;i++)
  	{
  		PORTD=sel;
  a0:	42 bb       	out	0x12, r20	; 18
   		PORTB=0xff-Table[p[i]];
  a2:	fb 01       	movw	r30, r22
  a4:	e2 0f       	add	r30, r18
  a6:	f3 1f       	adc	r31, r19
  a8:	e0 81       	ld	r30, Z
  aa:	f0 e0       	ldi	r31, 0x00	; 0
  ac:	e0 5a       	subi	r30, 0xA0	; 160
  ae:	ff 4f       	sbci	r31, 0xFF	; 255
  b0:	80 81       	ld	r24, Z
  b2:	80 95       	com	r24
  b4:	88 bb       	out	0x18, r24	; 24
  b6:	fd 01       	movw	r30, r26
  b8:	31 97       	sbiw	r30, 0x01	; 1
  ba:	f1 f7       	brne	.-4      	; 0xb8 <Display+0x24>
   		_delay_ms(10);
   		//DelayMs(10);
   		sel=sel<<1;
  bc:	44 0f       	add	r20, r20
  be:	2f 5f       	subi	r18, 0xFF	; 255
  c0:	3f 4f       	sbci	r19, 0xFF	; 255
}

void Display(uint8_t *p)              //间隔5ms显示
{
	uint8_t i,sel=0x01;
 	for(i=0;i<4;i++)
  c2:	24 30       	cpi	r18, 0x04	; 4
  c4:	31 05       	cpc	r19, r1
  c6:	61 f7       	brne	.-40     	; 0xa0 <Display+0xc>
   		PORTB=0xff-Table[p[i]];
   		_delay_ms(10);
   		//DelayMs(10);
   		sel=sel<<1;
  	}
}
  c8:	08 95       	ret

000000ca <ADC_Convert>:
 	temp2=(temp2<<8)+temp1;
 	return(temp2);
}
*/
uint16_t ADC_Convert(void)
{
  ca:	ff 92       	push	r15
  cc:	0f 93       	push	r16
  ce:	1f 93       	push	r17
  d0:	cf 93       	push	r28
  d2:	df 93       	push	r29
	uint8_t i;
	uint16_t ret;
	uint8_t max_id, min_id, max_value, min_value;
	
	ADMUX  = (1<<MUX0);				// 外部参考电压，5通道
  d4:	81 e0       	ldi	r24, 0x01	; 1
  d6:	87 b9       	out	0x07, r24	; 7
	ADCSRA = (1<<ADEN);				// 使能ADC，单次转换模式
  d8:	80 e8       	ldi	r24, 0x80	; 128
  da:	86 b9       	out	0x06, r24	; 6
  dc:	e8 e7       	ldi	r30, 0x78	; 120
  de:	f0 e0       	ldi	r31, 0x00	; 0
    can be achieved.
*/
void
_delay_loop_1(uint8_t __count)
{
	__asm__ volatile (
  e0:	4c e3       	ldi	r20, 0x3C	; 60
	
	// 连续转换8次
	for(i=0;i<8;i++)
	{
		ADCSRA |= (1<<ADSC);			//开始
  e2:	36 9a       	sbi	0x06, 6	; 6
  e4:	84 2f       	mov	r24, r20
  e6:	8a 95       	dec	r24
  e8:	f1 f7       	brne	.-4      	; 0xe6 <ADC_Convert+0x1c>
		_delay_loop_1(60);
		while(ADCSRA & (1<<ADSC))
  ea:	36 99       	sbic	0x06, 6	; 6
  ec:	fb cf       	rjmp	.-10     	; 0xe4 <ADC_Convert+0x1a>
			_delay_loop_1(60);
		ret = ADCL;
  ee:	84 b1       	in	r24, 0x04	; 4
  f0:	90 e0       	ldi	r25, 0x00	; 0
		ret |= (uint16_t)(ADCH<<8);
  f2:	25 b1       	in	r18, 0x05	; 5
		g_aAdValue[i] = ret;			//单次
  f4:	32 2f       	mov	r19, r18
  f6:	20 e0       	ldi	r18, 0x00	; 0
  f8:	82 2b       	or	r24, r18
  fa:	93 2b       	or	r25, r19
  fc:	81 93       	st	Z+, r24
  fe:	91 93       	st	Z+, r25
	
	ADMUX  = (1<<MUX0);				// 外部参考电压，5通道
	ADCSRA = (1<<ADEN);				// 使能ADC，单次转换模式
	
	// 连续转换8次
	for(i=0;i<8;i++)
 100:	80 e0       	ldi	r24, 0x00	; 0
 102:	e8 38       	cpi	r30, 0x88	; 136
 104:	f8 07       	cpc	r31, r24
 106:	69 f7       	brne	.-38     	; 0xe2 <ADC_Convert+0x18>
 108:	ef 01       	movw	r28, r30
 10a:	2e 97       	sbiw	r28, 0x0e	; 14
 10c:	fe 01       	movw	r30, r28
 10e:	20 e0       	ldi	r18, 0x00	; 0
 110:	30 e0       	ldi	r19, 0x00	; 0
		ret |= (uint16_t)(ADCH<<8);
		g_aAdValue[i] = ret;			//单次
	}
	ret = 0;
	for(i=1;i<8;i++)
		ret += g_aAdValue[i];
 112:	81 91       	ld	r24, Z+
 114:	91 91       	ld	r25, Z+
 116:	28 0f       	add	r18, r24
 118:	39 1f       	adc	r19, r25
		ret = ADCL;
		ret |= (uint16_t)(ADCH<<8);
		g_aAdValue[i] = ret;			//单次
	}
	ret = 0;
	for(i=1;i<8;i++)
 11a:	80 e0       	ldi	r24, 0x00	; 0
 11c:	e8 38       	cpi	r30, 0x88	; 136
 11e:	f8 07       	cpc	r31, r24
 120:	c1 f7       	brne	.-16     	; 0x112 <ADC_Convert+0x48>
		ret += g_aAdValue[i];
	
	// 找到最大和最小值索引
	ret /= 7;
 122:	c9 01       	movw	r24, r18
 124:	67 e0       	ldi	r22, 0x07	; 7
 126:	70 e0       	ldi	r23, 0x00	; 0
 128:	0e 94 64 02 	call	0x4c8	; 0x4c8 <__udivmodhi4>
 12c:	ab 01       	movw	r20, r22
 12e:	3e 97       	sbiw	r30, 0x0e	; 14
 130:	a1 e0       	ldi	r26, 0x01	; 1
 132:	11 e0       	ldi	r17, 0x01	; 1
 134:	b1 e0       	ldi	r27, 0x01	; 1
 136:	ff 24       	eor	r15, r15
 138:	00 e0       	ldi	r16, 0x00	; 0
	max_id = min_id = 1;
	max_value = min_value = 0;
	for(i=1;i<8;i++)
	{
		if(g_aAdValue[i] > ret)
 13a:	60 81       	ld	r22, Z
 13c:	71 81       	ldd	r23, Z+1	; 0x01
 13e:	46 17       	cp	r20, r22
 140:	57 07       	cpc	r21, r23
 142:	60 f4       	brcc	.+24     	; 0x15c <ADC_Convert+0x92>
		{
			if(g_aAdValue[i] - ret > max_value)
 144:	9b 01       	movw	r18, r22
 146:	24 1b       	sub	r18, r20
 148:	35 0b       	sbc	r19, r21
 14a:	8f 2d       	mov	r24, r15
 14c:	90 e0       	ldi	r25, 0x00	; 0
 14e:	82 17       	cp	r24, r18
 150:	93 07       	cpc	r25, r19
 152:	78 f4       	brcc	.+30     	; 0x172 <ADC_Convert+0xa8>
			{
				max_value = g_aAdValue[i] - ret;
 154:	f6 2e       	mov	r15, r22
 156:	f4 1a       	sub	r15, r20
 158:	1a 2f       	mov	r17, r26
 15a:	0b c0       	rjmp	.+22     	; 0x172 <ADC_Convert+0xa8>
				max_id = i;
			}
		}
		else
		{
			if(ret - g_aAdValue[i] > min_value)
 15c:	9a 01       	movw	r18, r20
 15e:	26 1b       	sub	r18, r22
 160:	37 0b       	sbc	r19, r23
 162:	80 2f       	mov	r24, r16
 164:	90 e0       	ldi	r25, 0x00	; 0
 166:	82 17       	cp	r24, r18
 168:	93 07       	cpc	r25, r19
 16a:	18 f4       	brcc	.+6      	; 0x172 <ADC_Convert+0xa8>
			{
				min_value = ret - g_aAdValue[i];
 16c:	04 2f       	mov	r16, r20
 16e:	06 1b       	sub	r16, r22
 170:	ba 2f       	mov	r27, r26
	
	// 找到最大和最小值索引
	ret /= 7;
	max_id = min_id = 1;
	max_value = min_value = 0;
	for(i=1;i<8;i++)
 172:	af 5f       	subi	r26, 0xFF	; 255
 174:	32 96       	adiw	r30, 0x02	; 2
 176:	a8 30       	cpi	r26, 0x08	; 8
 178:	01 f7       	brne	.-64     	; 0x13a <ADC_Convert+0x70>
 17a:	41 e0       	ldi	r20, 0x01	; 1
 17c:	20 e0       	ldi	r18, 0x00	; 0
 17e:	30 e0       	ldi	r19, 0x00	; 0
	
	// 去掉第一个和最大最小值后的平均值
	ret = 0;
	for(i=1;i<8;i++)
	{
		if((i!=min_id) && (i!=max_id))
 180:	4b 17       	cp	r20, r27
 182:	31 f0       	breq	.+12     	; 0x190 <ADC_Convert+0xc6>
 184:	41 17       	cp	r20, r17
 186:	21 f0       	breq	.+8      	; 0x190 <ADC_Convert+0xc6>
			ret += g_aAdValue[i];
 188:	88 81       	ld	r24, Y
 18a:	99 81       	ldd	r25, Y+1	; 0x01
 18c:	28 0f       	add	r18, r24
 18e:	39 1f       	adc	r19, r25
		}
	}
	
	// 去掉第一个和最大最小值后的平均值
	ret = 0;
	for(i=1;i<8;i++)
 190:	4f 5f       	subi	r20, 0xFF	; 255
 192:	22 96       	adiw	r28, 0x02	; 2
 194:	48 30       	cpi	r20, 0x08	; 8
 196:	a1 f7       	brne	.-24     	; 0x180 <ADC_Convert+0xb6>
	{
		if((i!=min_id) && (i!=max_id))
			ret += g_aAdValue[i];
	}
	if(min_id != max_id)
 198:	b1 17       	cp	r27, r17
 19a:	21 f0       	breq	.+8      	; 0x1a4 <ADC_Convert+0xda>
		ret /= 5;
 19c:	c9 01       	movw	r24, r18
 19e:	65 e0       	ldi	r22, 0x05	; 5
 1a0:	70 e0       	ldi	r23, 0x00	; 0
 1a2:	03 c0       	rjmp	.+6      	; 0x1aa <ADC_Convert+0xe0>
	else
		ret /= 6;
 1a4:	c9 01       	movw	r24, r18
 1a6:	66 e0       	ldi	r22, 0x06	; 6
 1a8:	70 e0       	ldi	r23, 0x00	; 0
 1aa:	0e 94 64 02 	call	0x4c8	; 0x4c8 <__udivmodhi4>

	ADCSRA = 0x00;					// 关闭ADC
 1ae:	16 b8       	out	0x06, r1	; 6
	
	return ret;	
}
 1b0:	cb 01       	movw	r24, r22
 1b2:	df 91       	pop	r29
 1b4:	cf 91       	pop	r28
 1b6:	1f 91       	pop	r17
 1b8:	0f 91       	pop	r16
 1ba:	ff 90       	pop	r15
 1bc:	08 95       	ret

000001be <Process>:

void Process(uint16_t i,uint8_t *p)
{
 1be:	9c 01       	movw	r18, r24
 1c0:	fb 01       	movw	r30, r22
	p[0]=i/1000;
 1c2:	68 ee       	ldi	r22, 0xE8	; 232
 1c4:	73 e0       	ldi	r23, 0x03	; 3
 1c6:	0e 94 64 02 	call	0x4c8	; 0x4c8 <__udivmodhi4>
 1ca:	60 83       	st	Z, r22
 	i=i%1000;
 1cc:	c9 01       	movw	r24, r18
 1ce:	68 ee       	ldi	r22, 0xE8	; 232
 1d0:	73 e0       	ldi	r23, 0x03	; 3
 1d2:	0e 94 64 02 	call	0x4c8	; 0x4c8 <__udivmodhi4>
 1d6:	9c 01       	movw	r18, r24
 	p[1]=i/100;
 1d8:	64 e6       	ldi	r22, 0x64	; 100
 1da:	70 e0       	ldi	r23, 0x00	; 0
 1dc:	0e 94 64 02 	call	0x4c8	; 0x4c8 <__udivmodhi4>
 1e0:	61 83       	std	Z+1, r22	; 0x01
 	i=i%100;
 1e2:	c9 01       	movw	r24, r18
 1e4:	64 e6       	ldi	r22, 0x64	; 100
 1e6:	70 e0       	ldi	r23, 0x00	; 0
 1e8:	0e 94 64 02 	call	0x4c8	; 0x4c8 <__udivmodhi4>
 1ec:	9c 01       	movw	r18, r24
 	p[2]=i/10;
 1ee:	6a e0       	ldi	r22, 0x0A	; 10
 1f0:	70 e0       	ldi	r23, 0x00	; 0
 1f2:	0e 94 64 02 	call	0x4c8	; 0x4c8 <__udivmodhi4>
 1f6:	62 83       	std	Z+2, r22	; 0x02
 	i=i%10;
 	p[3]=i;
 1f8:	c9 01       	movw	r24, r18
 1fa:	6a e0       	ldi	r22, 0x0A	; 10
 1fc:	70 e0       	ldi	r23, 0x00	; 0
 1fe:	0e 94 64 02 	call	0x4c8	; 0x4c8 <__udivmodhi4>
 202:	83 83       	std	Z+3, r24	; 0x03
}
 204:	08 95       	ret

00000206 <main>:

int main(void)
{
 206:	cf 93       	push	r28
 208:	df 93       	push	r29
	uint16_t ret;
 	DDRA=0x00;                    //设置A口为不带上拉输入；
 20a:	1a ba       	out	0x1a, r1	; 26
 	PORTA=0x00;
 20c:	1b ba       	out	0x1b, r1	; 27
 	DDRB=0xff;                    //设置B口为推挽1输出；
 20e:	8f ef       	ldi	r24, 0xFF	; 255
 210:	87 bb       	out	0x17, r24	; 23
 	PORTB=0xff;
 212:	88 bb       	out	0x18, r24	; 24
 	DDRD=0xff;                    //设置C口为推挽1输出；
 214:	81 bb       	out	0x11, r24	; 17
 	PORTD=0xff;
 216:	82 bb       	out	0x12, r24	; 18
12 下一页
💿 文件大小 61 K
👤 上传用户 youwei15
📂 所属分类单片机开发
🏷️ 相关标签

#ATmega #AVR #16 #单片机
⌨️ 快捷键说明

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