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

📄 adled.lss

📁 AVR单片机AD转换及LED显示源程序,已经在仿真文件中成功调试
💻 LSS
📖 第 1 页 / 共 5 页
字号:

adled.elf:     file format elf32-avr

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .text         00000f8e  00000000  00000000  00000094  2**0
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  1 .data         00000008  00800060  00000f8e  00001022  2**0
                  CONTENTS, ALLOC, LOAD, DATA
  2 .bss          00000016  00800068  00800068  0000102a  2**0
                  ALLOC
  3 .noinit       00000000  0080007e  0080007e  0000102a  2**0
                  CONTENTS
  4 .eeprom       00000000  00810000  00810000  0000102a  2**0
                  CONTENTS
  5 .stab         0000036c  00000000  00000000  0000102c  2**2
                  CONTENTS, READONLY, DEBUGGING
  6 .stabstr      00000084  00000000  00000000  00001398  2**0
                  CONTENTS, READONLY, DEBUGGING
  7 .debug_aranges 00000014  00000000  00000000  0000141c  2**0
                  CONTENTS, READONLY, DEBUGGING
  8 .debug_pubnames 0000002a  00000000  00000000  00001430  2**0
                  CONTENTS, READONLY, DEBUGGING
  9 .debug_info   00000175  00000000  00000000  0000145a  2**0
                  CONTENTS, READONLY, DEBUGGING
 10 .debug_abbrev 000000bf  00000000  00000000  000015cf  2**0
                  CONTENTS, READONLY, DEBUGGING
 11 .debug_line   000001d6  00000000  00000000  0000168e  2**0
                  CONTENTS, READONLY, DEBUGGING
 12 .debug_str    000000c0  00000000  00000000  00001864  2**0
                  CONTENTS, READONLY, DEBUGGING
Disassembly of section .text:

00000000 <__vectors>:
   0:	10 c0       	rjmp	.+32     	; 0x22 <__ctors_end>
   2:	2a c0       	rjmp	.+84     	; 0x58 <__bad_interrupt>
   4:	29 c0       	rjmp	.+82     	; 0x58 <__bad_interrupt>
   6:	28 c0       	rjmp	.+80     	; 0x58 <__bad_interrupt>
   8:	27 c0       	rjmp	.+78     	; 0x58 <__bad_interrupt>
   a:	26 c0       	rjmp	.+76     	; 0x58 <__bad_interrupt>
   c:	25 c0       	rjmp	.+74     	; 0x58 <__bad_interrupt>
   e:	24 c0       	rjmp	.+72     	; 0x58 <__bad_interrupt>
  10:	23 c0       	rjmp	.+70     	; 0x58 <__bad_interrupt>
  12:	22 c0       	rjmp	.+68     	; 0x58 <__bad_interrupt>
  14:	21 c0       	rjmp	.+66     	; 0x58 <__bad_interrupt>
  16:	20 c0       	rjmp	.+64     	; 0x58 <__bad_interrupt>
  18:	1f c0       	rjmp	.+62     	; 0x58 <__bad_interrupt>
  1a:	1e c0       	rjmp	.+60     	; 0x58 <__bad_interrupt>
  1c:	1d c0       	rjmp	.+58     	; 0x58 <__bad_interrupt>
  1e:	1c c0       	rjmp	.+56     	; 0x58 <__bad_interrupt>
  20:	1b c0       	rjmp	.+54     	; 0x58 <__bad_interrupt>

00000022 <__ctors_end>:
  22:	11 24       	eor	r1, r1
  24:	1f be       	out	0x3f, r1	; 63
  26:	cf e5       	ldi	r28, 0x5F	; 95
  28:	d2 e0       	ldi	r29, 0x02	; 2
  2a:	de bf       	out	0x3e, r29	; 62
  2c:	cd bf       	out	0x3d, r28	; 61

0000002e <__do_copy_data>:
  2e:	10 e0       	ldi	r17, 0x00	; 0
  30:	a0 e6       	ldi	r26, 0x60	; 96
  32:	b0 e0       	ldi	r27, 0x00	; 0
  34:	ee e8       	ldi	r30, 0x8E	; 142
  36:	ff e0       	ldi	r31, 0x0F	; 15
  38:	03 c0       	rjmp	.+6      	; 0x40 <.do_copy_data_start>

0000003a <.do_copy_data_loop>:
  3a:	c8 95       	lpm
  3c:	31 96       	adiw	r30, 0x01	; 1
  3e:	0d 92       	st	X+, r0

00000040 <.do_copy_data_start>:
  40:	a8 36       	cpi	r26, 0x68	; 104
  42:	b1 07       	cpc	r27, r17
  44:	d1 f7       	brne	.-12     	; 0x3a <.do_copy_data_loop>

00000046 <__do_clear_bss>:
  46:	10 e0       	ldi	r17, 0x00	; 0
  48:	a8 e6       	ldi	r26, 0x68	; 104
  4a:	b0 e0       	ldi	r27, 0x00	; 0
  4c:	01 c0       	rjmp	.+2      	; 0x50 <.do_clear_bss_start>

0000004e <.do_clear_bss_loop>:
  4e:	1d 92       	st	X+, r1

00000050 <.do_clear_bss_start>:
  50:	ae 37       	cpi	r26, 0x7E	; 126
  52:	b1 07       	cpc	r27, r17
  54:	e1 f7       	brne	.-8      	; 0x4e <.do_clear_bss_loop>
  56:	7f c0       	rjmp	.+254    	; 0x156 <main>

00000058 <__bad_interrupt>:
  58:	d3 cf       	rjmp	.-90     	; 0x0 <__vectors>

0000005a <AdcConvert>:
  stdin=&mystd;
} */
//AD转换8次去掉最高和最低后取平均值返回
uint16_t AdcConvert(void)
{
  5a:	cf 93       	push	r28
  uint8_t i;
  uint16_t ret;
  uint8_t max_id,min_id,max_value,min_value;
  
  ADMUX=0Xc0;//内部2.56V参考电压,0通道
  5c:	80 ec       	ldi	r24, 0xC0	; 192
  5e:	87 b9       	out	0x07, r24	; 7
  ADCSR=_BV(ADEN);//使能ADC,单次转换模式
  60:	80 e8       	ldi	r24, 0x80	; 128
  62:	86 b9       	out	0x06, r24	; 6
  64:	47 e0       	ldi	r20, 0x07	; 7
  66:	e8 e6       	ldi	r30, 0x68	; 104
  68:	f0 e0       	ldi	r31, 0x00	; 0
  
  //连续转换8次
  for(i=0;i<8;i++)
  {
    ADCSR|=_BV(ADSC);
  6a:	36 9a       	sbi	0x06, 6	; 6
    can be achieved.
*/
void
_delay_loop_1(uint8_t __count)
{
  6c:	8c e3       	ldi	r24, 0x3C	; 60
	__asm__ volatile (
  6e:	8a 95       	dec	r24
  70:	f1 f7       	brne	.-4      	; 0x6e <AdcConvert+0x14>
  72:	36 9b       	sbis	0x06, 6	; 6
  74:	05 c0       	rjmp	.+10     	; 0x80 <AdcConvert+0x26>
  76:	8c e3       	ldi	r24, 0x3C	; 60
  78:	8a 95       	dec	r24
  7a:	f1 f7       	brne	.-4      	; 0x78 <AdcConvert+0x1e>
  7c:	36 99       	sbic	0x06, 6	; 6
  7e:	fb cf       	rjmp	.-10     	; 0x76 <AdcConvert+0x1c>
    _delay_loop_1(60);
    while(ADCSR&_BV(ADSC))
      _delay_loop_1(60);
    ret=ADCL;
  80:	84 b1       	in	r24, 0x04	; 4
  82:	68 2f       	mov	r22, r24
  84:	77 27       	eor	r23, r23
    ret|=(uint16_t)(ADCH<<8);
  86:	85 b1       	in	r24, 0x05	; 5
  88:	99 27       	eor	r25, r25
  8a:	98 2f       	mov	r25, r24
  8c:	88 27       	eor	r24, r24
  8e:	86 2b       	or	r24, r22
  90:	97 2b       	or	r25, r23
    g_aAdValue[i]=ret;
  92:	81 93       	st	Z+, r24
  94:	91 93       	st	Z+, r25
  96:	41 50       	subi	r20, 0x01	; 1
  98:	47 ff       	sbrs	r20, 7
  9a:	e7 cf       	rjmp	.-50     	; 0x6a <AdcConvert+0x10>
  }
  ret=0;
  9c:	60 e0       	ldi	r22, 0x00	; 0
  9e:	70 e0       	ldi	r23, 0x00	; 0
  a0:	46 e0       	ldi	r20, 0x06	; 6
  a2:	ea e6       	ldi	r30, 0x6A	; 106
  a4:	f0 e0       	ldi	r31, 0x00	; 0
  for(i=1;i<8;i++)
    ret+=g_aAdValue[i];
  a6:	81 91       	ld	r24, Z+
  a8:	91 91       	ld	r25, Z+
  aa:	68 0f       	add	r22, r24
  ac:	79 1f       	adc	r23, r25
  ae:	41 50       	subi	r20, 0x01	; 1
  b0:	47 ff       	sbrs	r20, 7
  b2:	f9 cf       	rjmp	.-14     	; 0xa6 <AdcConvert+0x4c>
  
  //找到最大和最小值索引  
  ret/=7;
  b4:	97 2f       	mov	r25, r23
  b6:	86 2f       	mov	r24, r22
  b8:	67 e0       	ldi	r22, 0x07	; 7
  ba:	70 e0       	ldi	r23, 0x00	; 0
  bc:	b6 d6       	rcall	.+3436   	; 0xe2a <__udivmodhi4>
  max_id=min_id=1;
  be:	b1 e0       	ldi	r27, 0x01	; 1
  c0:	cb 2f       	mov	r28, r27
  max_value=min_value=0;
  c2:	a0 e0       	ldi	r26, 0x00	; 0
  c4:	5a 2f       	mov	r21, r26
  for(i=1;i<8;i++)
  c6:	4b 2f       	mov	r20, r27
  c8:	ea e6       	ldi	r30, 0x6A	; 106
  ca:	f0 e0       	ldi	r31, 0x00	; 0
  {
    if(g_aAdValue[i]>ret)
  cc:	20 81       	ld	r18, Z
  ce:	31 81       	ldd	r19, Z+1	; 0x01
  d0:	62 17       	cp	r22, r18
  d2:	73 07       	cpc	r23, r19
  d4:	58 f4       	brcc	.+22     	; 0xec <AdcConvert+0x92>
    {
      if(g_aAdValue[i]-ret>max_value)
  d6:	26 1b       	sub	r18, r22
  d8:	37 0b       	sbc	r19, r23
  da:	85 2f       	mov	r24, r21
  dc:	99 27       	eor	r25, r25
  de:	82 17       	cp	r24, r18
  e0:	93 07       	cpc	r25, r19
  e2:	98 f4       	brcc	.+38     	; 0x10a <AdcConvert+0xb0>
      {
        max_value=g_aAdValue[i]-ret;
  e4:	50 81       	ld	r21, Z
  e6:	56 1b       	sub	r21, r22
        max_id=i;
  e8:	c4 2f       	mov	r28, r20
  ea:	0f c0       	rjmp	.+30     	; 0x10a <AdcConvert+0xb0>
      }
    }
    else
    {
      if(ret-g_aAdValue[i]>min_value)
  ec:	97 2f       	mov	r25, r23
  ee:	86 2f       	mov	r24, r22
  f0:	82 1b       	sub	r24, r18
  f2:	93 0b       	sbc	r25, r19
  f4:	28 2f       	mov	r18, r24
  f6:	39 2f       	mov	r19, r25
  f8:	8a 2f       	mov	r24, r26
  fa:	99 27       	eor	r25, r25
  fc:	82 17       	cp	r24, r18
  fe:	93 07       	cpc	r25, r19
 100:	20 f4       	brcc	.+8      	; 0x10a <AdcConvert+0xb0>
      {
        min_value=ret-g_aAdValue[i];
 102:	80 81       	ld	r24, Z
 104:	a6 2f       	mov	r26, r22
 106:	a8 1b       	sub	r26, r24
        min_id=i;
 108:	b4 2f       	mov	r27, r20
 10a:	4f 5f       	subi	r20, 0xFF	; 255
 10c:	32 96       	adiw	r30, 0x02	; 2
 10e:	48 30       	cpi	r20, 0x08	; 8
 110:	e8 f2       	brcs	.-70     	; 0xcc <AdcConvert+0x72>
      }
    }
  }
  
  //去掉第一个和最大最小值后的平均值
  ret=0;
 112:	60 e0       	ldi	r22, 0x00	; 0
 114:	70 e0       	ldi	r23, 0x00	; 0
  for(i=1;i<8;i++)
 116:	41 e0       	ldi	r20, 0x01	; 1
 118:	ea e6       	ldi	r30, 0x6A	; 106
 11a:	f0 e0       	ldi	r31, 0x00	; 0
  {
    if((i!=min_id)&&(i!=max_id))
 11c:	4b 17       	cp	r20, r27
 11e:	31 f0       	breq	.+12     	; 0x12c <AdcConvert+0xd2>
 120:	4c 17       	cp	r20, r28
 122:	21 f0       	breq	.+8      	; 0x12c <AdcConvert+0xd2>
      ret+=g_aAdValue[i];     
 124:	80 81       	ld	r24, Z
 126:	91 81       	ldd	r25, Z+1	; 0x01
 128:	68 0f       	add	r22, r24
 12a:	79 1f       	adc	r23, r25
 12c:	4f 5f       	subi	r20, 0xFF	; 255
 12e:	32 96       	adiw	r30, 0x02	; 2
 130:	48 30       	cpi	r20, 0x08	; 8
 132:	a0 f3       	brcs	.-24     	; 0x11c <AdcConvert+0xc2>
  }
  if(min_id!=max_id)
 134:	bc 17       	cp	r27, r28
 136:	29 f0       	breq	.+10     	; 0x142 <AdcConvert+0xe8>
    ret/=5;
 138:	97 2f       	mov	r25, r23
 13a:	86 2f       	mov	r24, r22
 13c:	65 e0       	ldi	r22, 0x05	; 5
 13e:	70 e0       	ldi	r23, 0x00	; 0
 140:	04 c0       	rjmp	.+8      	; 0x14a <AdcConvert+0xf0>
  else  
    ret/=6;
 142:	97 2f       	mov	r25, r23
 144:	86 2f       	mov	r24, r22
 146:	66 e0       	ldi	r22, 0x06	; 6
 148:	70 e0       	ldi	r23, 0x00	; 0
 14a:	6f d6       	rcall	.+3294   	; 0xe2a <__udivmodhi4>

  ADCSR=0;//关闭ADC
 14c:	16 b8       	out	0x06, r1	; 6
  
  return ret;
}
 14e:	97 2f       	mov	r25, r23
 150:	86 2f       	mov	r24, r22
 152:	cf 91       	pop	r28
 154:	08 95       	ret

00000156 <main>:

int main(void)
{
 156:	ce e5       	ldi	r28, 0x5E	; 94
 158:	d2 e0       	ldi	r29, 0x02	; 2
 15a:	de bf       	out	0x3e, r29	; 62
 15c:	cd bf       	out	0x3d, r28	; 61
  uint8_t i;
  //IoInit();
  
  while(1)
  {
    scanf("%c",&i);
 15e:	8c 2f       	mov	r24, r28
 160:	9d 2f       	mov	r25, r29
 162:	01 96       	adiw	r24, 0x01	; 1
 164:	9f 93       	push	r25
 166:	8f 93       	push	r24
 168:	80 e6       	ldi	r24, 0x60	; 96
 16a:	90 e0       	ldi	r25, 0x00	; 0
 16c:	9f 93       	push	r25
 16e:	8f 93       	push	r24
 170:	2a d0       	rcall	.+84     	; 0x1c6 <scanf>
    if(i=='c')
 172:	89 81       	ldd	r24, Y+1	; 0x01
 174:	0f 90       	pop	r0
 176:	0f 90       	pop	r0
 178:	0f 90       	pop	r0
 17a:	0f 90       	pop	r0
 17c:	83 36       	cpi	r24, 0x63	; 99
 17e:	79 f7       	brne	.-34     	; 0x15e <main+0x8>
      printf("%d\n",AdcConvert());
 180:	6c df       	rcall	.-296    	; 0x5a <AdcConvert>
 182:	9f 93       	push	r25
 184:	8f 93       	push	r24
 186:	83 e6       	ldi	r24, 0x63	; 99
 188:	90 e0       	ldi	r25, 0x00	; 0
 18a:	9f 93       	push	r25
 18c:	8f 93       	push	r24
 18e:	05 d0       	rcall	.+10     	; 0x19a <printf>
 190:	0f 90       	pop	r0
 192:	0f 90       	pop	r0
 194:	0f 90       	pop	r0
 196:	0f 90       	pop	r0

⌨️ 快捷键说明

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