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

📄 m16_pwm.lss

📁 AVR单片机ATmega16的PWM测试程序
💻 LSS
📖 第 1 页 / 共 2 页
字号:

M16_PWM.elf:     file format elf32-avr

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .text         00000290  00000000  00000000  00000074  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  1 .data         00000014  00800060  00000290  00000304  2**0
                  CONTENTS, ALLOC, LOAD, DATA
  2 .bss          00000002  00800074  000002a4  00000318  2**0
                  ALLOC
  3 .debug_aranges 00000020  00000000  00000000  00000318  2**0
                  CONTENTS, READONLY, DEBUGGING
  4 .debug_pubnames 00000093  00000000  00000000  00000338  2**0
                  CONTENTS, READONLY, DEBUGGING
  5 .debug_info   000003da  00000000  00000000  000003cb  2**0
                  CONTENTS, READONLY, DEBUGGING
  6 .debug_abbrev 000001da  00000000  00000000  000007a5  2**0
                  CONTENTS, READONLY, DEBUGGING
  7 .debug_line   000003b4  00000000  00000000  0000097f  2**0
                  CONTENTS, READONLY, DEBUGGING
  8 .debug_frame  00000080  00000000  00000000  00000d34  2**2
                  CONTENTS, READONLY, DEBUGGING
  9 .debug_str    000000f8  00000000  00000000  00000db4  2**0
                  CONTENTS, READONLY, DEBUGGING
 10 .debug_loc    00000191  00000000  00000000  00000eac  2**0
                  CONTENTS, READONLY, DEBUGGING
 11 .debug_ranges 000001b0  00000000  00000000  0000103d  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:	e0 e9       	ldi	r30, 0x90	; 144
  68:	f2 e0       	ldi	r31, 0x02	; 2
  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:	a6 37       	cpi	r26, 0x76	; 118
  82:	b1 07       	cpc	r27, r17
  84:	e1 f7       	brne	.-8      	; 0x7e <.do_clear_bss_loop>
  86:	0e 94 f7 00 	call	0x1ee	; 0x1ee <main>
  8a:	0c 94 46 01 	jmp	0x28c	; 0x28c <_exit>

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

00000092 <display>:
uint8 data1[4]  = {10,0,5,0};
uint8 data2[4]  = {3,9,1,0};
uint8 key1, key2;

void display(uint8 *p)
{
  92:	bc 01       	movw	r22, r24
  94:	41 e0       	ldi	r20, 0x01	; 1
  96:	20 e0       	ldi	r18, 0x00	; 0
  98:	30 e0       	ldi	r19, 0x00	; 0
    milliseconds can be achieved.
 */
void
_delay_loop_2(uint16_t __count)
{
	__asm__ volatile (
  9a:	a4 ec       	ldi	r26, 0xC4	; 196
  9c:	b9 e0       	ldi	r27, 0x09	; 9
		uint8 sel = 0x01;
		for (uint8 i = 0; i < 4; i++)
		{
			PORTC = sel;
  9e:	45 bb       	out	0x15, r20	; 21
			PORTA = 0xff - table[p[i]];
  a0:	fb 01       	movw	r30, r22
  a2:	e2 0f       	add	r30, r18
  a4:	f3 1f       	adc	r31, r19
  a6:	e0 81       	ld	r30, Z
  a8:	f0 e0       	ldi	r31, 0x00	; 0
  aa:	e0 5a       	subi	r30, 0xA0	; 160
  ac:	ff 4f       	sbci	r31, 0xFF	; 255
  ae:	80 81       	ld	r24, Z
  b0:	80 95       	com	r24
  b2:	8b bb       	out	0x1b, r24	; 27
  b4:	fd 01       	movw	r30, r26
  b6:	31 97       	sbiw	r30, 0x01	; 1
  b8:	f1 f7       	brne	.-4      	; 0xb6 <display+0x24>
			_delay_ms(10);
			sel <<= 1;	
  ba:	44 0f       	add	r20, r20
  bc:	2f 5f       	subi	r18, 0xFF	; 255
  be:	3f 4f       	sbci	r19, 0xFF	; 255
uint8 key1, key2;

void display(uint8 *p)
{
		uint8 sel = 0x01;
		for (uint8 i = 0; i < 4; i++)
  c0:	24 30       	cpi	r18, 0x04	; 4
  c2:	31 05       	cpc	r19, r1
  c4:	61 f7       	brne	.-40     	; 0x9e <display+0xc>
			PORTC = sel;
			PORTA = 0xff - table[p[i]];
			_delay_ms(10);
			sel <<= 1;	
		}
}
  c6:	08 95       	ret

000000c8 <add>:

void add(uint8 *p)
{
  c8:	fc 01       	movw	r30, r24
	if (p[1] != 1)
  ca:	81 81       	ldd	r24, Z+1	; 0x01
  cc:	81 30       	cpi	r24, 0x01	; 1
  ce:	49 f0       	breq	.+18     	; 0xe2 <add+0x1a>
	{
		p[2]++;
  d0:	82 81       	ldd	r24, Z+2	; 0x02
  d2:	8f 5f       	subi	r24, 0xFF	; 255
  d4:	82 83       	std	Z+2, r24	; 0x02
		if (p[2] == 10)
  d6:	8a 30       	cpi	r24, 0x0A	; 10
  d8:	21 f4       	brne	.+8      	; 0xe2 <add+0x1a>
		{
			p[2] = 0;
  da:	12 82       	std	Z+2, r1	; 0x02
			p[1]++;		
  dc:	81 81       	ldd	r24, Z+1	; 0x01
  de:	8f 5f       	subi	r24, 0xFF	; 255
  e0:	81 83       	std	Z+1, r24	; 0x01
  e2:	08 95       	ret

000000e4 <sub>:
		}			
	}	
}

void sub(uint8 *p)
{
  e4:	fc 01       	movw	r30, r24
	uint8 tmp;
	tmp = p[1] * 10 + p[2];
  e6:	81 81       	ldd	r24, Z+1	; 0x01
  e8:	2a e0       	ldi	r18, 0x0A	; 10
  ea:	82 9f       	mul	r24, r18
  ec:	c0 01       	movw	r24, r0
  ee:	11 24       	eor	r1, r1
  f0:	22 81       	ldd	r18, Z+2	; 0x02
  f2:	28 0f       	add	r18, r24
	if (tmp != 0)
  f4:	51 f0       	breq	.+20     	; 0x10a <sub+0x26>
	{
		tmp -= 1;
  f6:	21 50       	subi	r18, 0x01	; 1
		p[1] = tmp / 10;
  f8:	82 2f       	mov	r24, r18
  fa:	6a e0       	ldi	r22, 0x0A	; 10
  fc:	0e 94 26 01 	call	0x24c	; 0x24c <__udivmodqi4>
 100:	81 83       	std	Z+1, r24	; 0x01
		p[2] = tmp % 10;	
 102:	82 2f       	mov	r24, r18
 104:	0e 94 26 01 	call	0x24c	; 0x24c <__udivmodqi4>
 108:	92 83       	std	Z+2, r25	; 0x02
 10a:	08 95       	ret

0000010c <key_process>:
	}	
}

void key_process(void)
{
 10c:	31 e0       	ldi	r19, 0x01	; 1
 10e:	44 ec       	ldi	r20, 0xC4	; 196
 110:	59 e0       	ldi	r21, 0x09	; 9
 112:	12 c0       	rjmp	.+36     	; 0x138 <key_process+0x2c>
void display(uint8 *p)
{
		uint8 sel = 0x01;
		for (uint8 i = 0; i < 4; i++)
		{
			PORTC = sel;
 114:	25 bb       	out	0x15, r18	; 21
			PORTA = 0xff - table[p[i]];
 116:	ed 91       	ld	r30, X+
 118:	f0 e0       	ldi	r31, 0x00	; 0
 11a:	e0 5a       	subi	r30, 0xA0	; 160
 11c:	ff 4f       	sbci	r31, 0xFF	; 255
 11e:	80 81       	ld	r24, Z
 120:	80 95       	com	r24
 122:	8b bb       	out	0x1b, r24	; 27
 124:	ca 01       	movw	r24, r20
 126:	01 97       	sbiw	r24, 0x01	; 1
 128:	f1 f7       	brne	.-4      	; 0x126 <key_process+0x1a>
			_delay_ms(10);
			sel <<= 1;	
 12a:	22 0f       	add	r18, r18
uint8 key1, key2;

void display(uint8 *p)
{
		uint8 sel = 0x01;
		for (uint8 i = 0; i < 4; i++)
 12c:	80 e0       	ldi	r24, 0x00	; 0
 12e:	a0 37       	cpi	r26, 0x70	; 112
 130:	b8 07       	cpc	r27, r24
 132:	81 f7       	brne	.-32     	; 0x114 <key_process+0x8>
void key_process(void)
{
		while ((PINB & 0x01) == 0)
		{
			display(data1);
			key1 = 1;
 134:	30 93 74 00 	sts	0x0074, r19
	}	
}

void key_process(void)
{
		while ((PINB & 0x01) == 0)
 138:	b0 99       	sbic	0x16, 0	; 22
 13a:	17 c0       	rjmp	.+46     	; 0x16a <key_process+0x5e>
 13c:	ac e6       	ldi	r26, 0x6C	; 108
 13e:	b0 e0       	ldi	r27, 0x00	; 0
 140:	21 e0       	ldi	r18, 0x01	; 1
 142:	e8 cf       	rjmp	.-48     	; 0x114 <key_process+0x8>
void display(uint8 *p)
{
		uint8 sel = 0x01;
		for (uint8 i = 0; i < 4; i++)
		{

⌨️ 快捷键说明

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