main.lss

DC Power 基于Mega8数控电源

}

static void lcd_out_low(u08 d)
{	/* output low nibble */
	if (d&0x08)  sbi(LCD_DATA_PORT_D7,LCD_DATA_PIN_D7);
     70a:	81 2f       	mov	r24, r17
     70c:	13 ff       	sbrs	r17, 3
     70e:	02 c0       	rjmp	.+4      	; 0x714 <lcd_write+0x30>
     710:	c7 9a       	sbi	0x18, 7	; 24
     712:	01 c0       	rjmp	.+2      	; 0x716 <lcd_write+0x32>
		else cbi(LCD_DATA_PORT_D7,LCD_DATA_PIN_D7);
     714:	c7 98       	cbi	0x18, 7	; 24
	if (d&0x04)  sbi(LCD_DATA_PORT_D6,LCD_DATA_PIN_D6);
     716:	82 ff       	sbrs	r24, 2
     718:	02 c0       	rjmp	.+4      	; 0x71e <lcd_write+0x3a>
     71a:	c2 9a       	sbi	0x18, 2	; 24
     71c:	01 c0       	rjmp	.+2      	; 0x720 <lcd_write+0x3c>
		else cbi(LCD_DATA_PORT_D6,LCD_DATA_PIN_D6);
     71e:	c2 98       	cbi	0x18, 2	; 24
	if (d&0x02)  sbi(LCD_DATA_PORT_D5,LCD_DATA_PIN_D5);
     720:	81 ff       	sbrs	r24, 1
     722:	02 c0       	rjmp	.+4      	; 0x728 <lcd_write+0x44>
     724:	c1 9a       	sbi	0x18, 1	; 24
     726:	01 c0       	rjmp	.+2      	; 0x72a <lcd_write+0x46>
		else cbi(LCD_DATA_PORT_D5,LCD_DATA_PIN_D5);
     728:	c1 98       	cbi	0x18, 1	; 24
	if (d&0x01)  sbi(LCD_DATA_PORT_D4,LCD_DATA_PIN_D4);
     72a:	80 ff       	sbrs	r24, 0
     72c:	02 c0       	rjmp	.+4      	; 0x732 <lcd_write+0x4e>
     72e:	c0 9a       	sbi	0x18, 0	; 24
     730:	01 c0       	rjmp	.+2      	; 0x734 <lcd_write+0x50>
		else cbi(LCD_DATA_PORT_D4,LCD_DATA_PIN_D4); 
     732:	c0 98       	cbi	0x18, 0	; 24
	lcd_e_toggle();

	/* output low nibble */
	lcd_out_low(data);

	if (rs)
     734:	00 23       	and	r16, r16
     736:	11 f0       	breq	.+4      	; 0x73c <lcd_write+0x58>
		lcd_data_mode();	/* RS=1: write data            */
     738:	c6 9a       	sbi	0x18, 6	; 24
     73a:	01 c0       	rjmp	.+2      	; 0x73e <lcd_write+0x5a>
	else
		lcd_cmd_mode();	/* RS=0: write instruction     */
     73c:	c6 98       	cbi	0x18, 6	; 24
}

static void lcd_e_toggle(void)
/* toggle Enable Pin */
{
	lcd_e_high();
     73e:	c4 9a       	sbi	0x18, 4	; 24
     740:	84 e0       	ldi	r24, 0x04	; 4
     742:	8a 95       	dec	r24
     744:	f1 f7       	brne	.-4      	; 0x742 <lcd_write+0x5e>
	_delay_us(3);
	lcd_e_low();
     746:	c4 98       	cbi	0x18, 4	; 24
	else
		lcd_cmd_mode();	/* RS=0: write instruction     */

	lcd_e_toggle();

}
     748:	1f 91       	pop	r17
     74a:	0f 91       	pop	r16
     74c:	08 95       	ret

0000074e <lcd_command>:
** PUBLIC FUNCTIONS 
*/

void lcd_command(u08 cmd)
/* send commando <cmd> to LCD */
{
     74e:	1f 93       	push	r17
     750:	1a e0       	ldi	r17, 0x0A	; 10
     752:	91 2f       	mov	r25, r17
     754:	9a 95       	dec	r25
     756:	f1 f7       	brne	.-4      	; 0x754 <lcd_command+0x6>
	lcd_waitcmd(0);
	lcd_write(cmd, 0);
     758:	60 e0       	ldi	r22, 0x00	; 0
     75a:	c4 df       	rcall	.-120    	; 0x6e4 <lcd_write>
     75c:	1a 95       	dec	r17
     75e:	f1 f7       	brne	.-4      	; 0x75c <lcd_command+0xe>
    milliseconds can be achieved.
 */
void
_delay_loop_2(uint16_t __count)
{
	__asm__ volatile (
     760:	80 ec       	ldi	r24, 0xC0	; 192
     762:	93 e0       	ldi	r25, 0x03	; 3
     764:	fc 01       	movw	r30, r24
     766:	31 97       	sbiw	r30, 0x01	; 1
     768:	f1 f7       	brne	.-4      	; 0x766 <lcd_command+0x18>
     76a:	01 97       	sbiw	r24, 0x01	; 1
     76c:	f1 f7       	brne	.-4      	; 0x76a <lcd_command+0x1c>
	lcd_waitcmd(1);
}
     76e:	1f 91       	pop	r17
     770:	08 95       	ret

00000772 <lcd_gotoxy>:
{
#if LCD_LINES==1
	lcd_command((1 << LCD_DDRAM) + LCD_START_LINE1 + x);
#endif
#if LCD_LINES==2
	if (y == 0)
     772:	66 23       	and	r22, r22
     774:	11 f4       	brne	.+4      	; 0x77a <lcd_gotoxy+0x8>
		lcd_command((1 << LCD_DDRAM) + LCD_START_LINE1 + x);
     776:	80 58       	subi	r24, 0x80	; 128
     778:	01 c0       	rjmp	.+2      	; 0x77c <lcd_gotoxy+0xa>
	else
		lcd_command((1 << LCD_DDRAM) + LCD_START_LINE2 + x);
     77a:	80 54       	subi	r24, 0x40	; 64
     77c:	e8 df       	rcall	.-48     	; 0x74e <lcd_command>
     77e:	08 95       	ret

00000780 <lcd_putc>:



void lcd_putc(char c)
/* print character at current cursor position */
{
     780:	1f 93       	push	r17
    can be achieved.
*/
void
_delay_loop_1(uint8_t __count)
{
	__asm__ volatile (
     782:	1a e0       	ldi	r17, 0x0A	; 10
     784:	91 2f       	mov	r25, r17
     786:	9a 95       	dec	r25
     788:	f1 f7       	brne	.-4      	; 0x786 <lcd_putc+0x6>
	lcd_waitcmd(0);
	lcd_write((unsigned char)c, 1);
     78a:	61 e0       	ldi	r22, 0x01	; 1
     78c:	ab df       	rcall	.-170    	; 0x6e4 <lcd_write>
     78e:	1a 95       	dec	r17
     790:	f1 f7       	brne	.-4      	; 0x78e <lcd_putc+0xe>
	lcd_waitcmd(0);
}
     792:	1f 91       	pop	r17
     794:	08 95       	ret

00000796 <lcd_puts>:


void lcd_puts(const char *s)
/* print string on lcd  */
{
     796:	cf 93       	push	r28
     798:	df 93       	push	r29
     79a:	ec 01       	movw	r28, r24
     79c:	02 c0       	rjmp	.+4      	; 0x7a2 <lcd_puts+0xc>
	while (*s) {
		lcd_putc(*s);
     79e:	f0 df       	rcall	.-32     	; 0x780 <lcd_putc>
		s++;
     7a0:	21 96       	adiw	r28, 0x01	; 1


void lcd_puts(const char *s)
/* print string on lcd  */
{
	while (*s) {
     7a2:	88 81       	ld	r24, Y
     7a4:	88 23       	and	r24, r24
     7a6:	d9 f7       	brne	.-10     	; 0x79e <lcd_puts+0x8>
		lcd_putc(*s);
		s++;
	}

}
     7a8:	df 91       	pop	r29
     7aa:	cf 91       	pop	r28
     7ac:	08 95       	ret

000007ae <lcd_puts_p>:


void lcd_puts_p(const prog_char *progmem_s)
/* print string from program memory on lcd  */
{
     7ae:	cf 93       	push	r28
     7b0:	df 93       	push	r29
     7b2:	ec 01       	movw	r28, r24
     7b4:	01 c0       	rjmp	.+2      	; 0x7b8 <lcd_puts_p+0xa>
	register char c;

	while ((c = pgm_read_byte(progmem_s++))) {
		lcd_putc(c);
     7b6:	e4 df       	rcall	.-56     	; 0x780 <lcd_putc>
     7b8:	fe 01       	movw	r30, r28
void lcd_puts_p(const prog_char *progmem_s)
/* print string from program memory on lcd  */
{
	register char c;

	while ((c = pgm_read_byte(progmem_s++))) {
     7ba:	21 96       	adiw	r28, 0x01	; 1
     7bc:	84 91       	lpm	r24, Z+
     7be:	88 23       	and	r24, r24
     7c0:	d1 f7       	brne	.-12     	; 0x7b6 <lcd_puts_p+0x8>
		lcd_putc(c);
	}

}
     7c2:	df 91       	pop	r29
     7c4:	cf 91       	pop	r28
     7c6:	08 95       	ret

000007c8 <lcd_init>:


void lcd_init(u08 dispAttr)
/* initialize display and select type of cursor */
/* dispAttr: LCD_DISP_OFF, LCD_DISP_ON, LCD_DISP_ON_CURSOR, LCD_DISP_CURSOR_BLINK */
{
     7c8:	0f 93       	push	r16
     7ca:	1f 93       	push	r17
     7cc:	cf 93       	push	r28
     7ce:	df 93       	push	r29
     7d0:	08 2f       	mov	r16, r24
    /*------ Initialize lcd to 4 bit i/o mode -------*/

	lcd_data_port_out();	/* all data port bits as output */
     7d2:	bf 9a       	sbi	0x17, 7	; 23
     7d4:	ba 9a       	sbi	0x17, 2	; 23
     7d6:	b9 9a       	sbi	0x17, 1	; 23
     7d8:	b8 9a       	sbi	0x17, 0	; 23
	sbi(LCD_RS_DDR, LCD_RS_PIN);	/* RS pin as output */
     7da:	be 9a       	sbi	0x17, 6	; 23
	sbi(LCD_E_DDR, LCD_E_PIN);	/* E  pin as output */
     7dc:	bc 9a       	sbi	0x17, 4	; 23
     7de:	2c e0       	ldi	r18, 0x0C	; 12
     7e0:	30 e0       	ldi	r19, 0x00	; 0
    milliseconds can be achieved.
 */
void
_delay_loop_2(uint16_t __count)
{
	__asm__ volatile (
     7e2:	40 ec       	ldi	r20, 0xC0	; 192
     7e4:	53 e0       	ldi	r21, 0x03	; 3
     7e6:	c0 ec       	ldi	r28, 0xC0	; 192
     7e8:	d3 e0       	ldi	r29, 0x03	; 3
     7ea:	ca 01       	movw	r24, r20
     7ec:	01 97       	sbiw	r24, 0x01	; 1
     7ee:	f1 f7       	brne	.-4      	; 0x7ec <lcd_init+0x24>
        // we use a calibrated macro. This is more
        // accurate and not so much compiler dependent
        // as self made code.
        while(ms){
                _delay_ms(0.96);
                ms--;
     7f0:	21 50       	subi	r18, 0x01	; 1
     7f2:	30 40       	sbci	r19, 0x00	; 0
/* delay for a minimum of <ms> */
{
        // we use a calibrated macro. This is more
        // accurate and not so much compiler dependent
        // as self made code.
        while(ms){
     7f4:	c1 f7       	brne	.-16     	; 0x7e6 <lcd_init+0x1e>


	lcd_delay_ms(12);	/* wait 12ms or more after power-on       */

	/* initial write to lcd is 8bit */
	lcd_out_high(LCD_FUNCTION_8BIT_1LINE);
     7f6:	80 e3       	ldi	r24, 0x30	; 48
     7f8:	60 df       	rcall	.-320    	; 0x6ba <lcd_out_high>
}

static void lcd_e_toggle(void)
/* toggle Enable Pin */
{
	lcd_e_high();
     7fa:	c4 9a       	sbi	0x18, 4	; 24
    can be achieved.
*/
void
_delay_loop_1(uint8_t __count)
{
	__asm__ volatile (
     7fc:	14 e0       	ldi	r17, 0x04	; 4
     7fe:	81 2f       	mov	r24, r17
     800:	8a 95       	dec	r24
     802:	f1 f7       	brne	.-4      	; 0x800 <lcd_init+0x38>
	_delay_us(3);
	lcd_e_low();
     804:	c4 98       	cbi	0x18, 4	; 24
    milliseconds can be achieved.
 */
void
_delay_loop_2(uint16_t __count)
{
	__asm__ volatile (
     806:	ce 01       	movw	r24, r28
     808:	01 97       	sbiw	r24, 0x01	; 1
     80a:	f1 f7       	brne	.-4      	; 0x808 <lcd_init+0x40>
     80c:	ce 01       	movw	r24, r28
     80e:	01 97       	sbiw	r24, 0x01	; 1
     810:	f1 f7       	brne	.-4      	; 0x80e <lcd_init+0x46>
	/* initial write to lcd is 8bit */
	lcd_out_high(LCD_FUNCTION_8BIT_1LINE);
	lcd_e_toggle();
	lcd_delay_ms(2);	/* delay, busy flag can't be checked here */

	lcd_out_high(LCD_FUNCTION_8BIT_1LINE);
     812:	80 e3       	ldi	r24, 0x30	; 48
     814:	52 df       	rcall	.-348    	; 0x6ba <lcd_out_high>
}

static void lcd_e_toggle(void)
/* toggle Enable Pin */
{
	lcd_e_high();
     816:	c4 9a       	sbi	0x18, 4	; 24
    can be achieved.
*/
void
_delay_loop_1(uint8_t __count)
{
	__asm__ volatile (
     818:	81 2f       	mov	r24, r17
     81a:	8a 95       	dec	r24
     81c:	f1 f7       	brne	.-4      	; 0x81a <lcd_init+0x52>
	_delay_us(3);
	lcd_e_low();
     81e:	c4 98       	cbi	0x18, 4	; 24
    milliseconds can be achieved.
 */
void
_delay_loop_2(uint16_t __count)
{
	__asm__ volatile (
     820:	ce 01       	movw	r24, r28
     822:	01 97       	sbiw	r24, 0x01	; 1
     824:	f1 f7       	brne	.-4      	; 0x822 <lcd_init+0x5a>
     826:	ce 01       	movw	r24, r28
     828:	01 97       	sbiw	r24, 0x01	; 1
     82a:	f1 f7       	brne	.-4      	; 0x828 <lcd_init+0x60>

	lcd_out_high(LCD_FUNCTION_8BIT_1LINE);
	lcd_e_toggle();
	lcd_delay_ms(2);	/* delay, busy flag can't be checked here */

	lcd_out_high(LCD_FUNCTION_8BIT_1LINE);
     82c:	80 e3       	ldi	r24, 0x30	; 48
     82e:	45 df       	rcall	.-374    	;