usart1.s

Atmega64单片机程序（完整工程）

	.module USART1.c
	.area vector(rom, abs)
	.org 120
	jmp _uart1_rx_isr
	.area text(rom, con, rel)
;           data -> R16
;         status -> R18
	.even
_uart1_rx_isr::
	st -y,R2
	st -y,R16
	st -y,R18
	st -y,R24
	st -y,R25
	st -y,R30
	st -y,R31
	in R2,0x3f
	st -y,R2
; /*******************************************************************************
; **--------------File Info-------------------------------------------------------
; ** 文   件   名:     USART1.c
; ** 最后修改日期:     2008-3-26
; ** 版        本:     V1.0
; ** 描        述:     M64串口一驱动											    header file
; **------------------------------------------------------------------------------
; ** Created by:	     
; ** Created date:     
; **------------------------------------------------------------------------------
; 
; *******************************************************************************/
; #include <USART1.h>
; 
; #if USART1_EN==1
; 
; INT8U rx_buffer1[RX_BUFFER_SIZE1];
; #if RX_BUFFER_SIZE1<256
;     INT8U rx_wr_index1,rx_rd_index1,rx_counter1;
; #else
;     INT16U rx_wr_index1,rx_rd_index1,rx_counter1;
; #endif
; INT8U rx_buffer_overflow1;
; 
; 
; INT8U tx_buffer1[TX_BUFFER_SIZE1];
; #if TX_BUFFER_SIZE1<256
;     INT8U tx_wr_index1,tx_rd_index1,tx_counter1;
; #else
;     INT16U tx_wr_index1,tx_rd_index1,tx_counter1;
; #endif
; 
; 
; #pragma interrupt_handler uart1_rx_isr:31
; void uart1_rx_isr(void)
; {
;     INT8U status,data;
;     status=UCSR1A;
	lds R18,155
;     data=UDR1;
	lds R16,156
;     if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0)
	mov R24,R18
	andi R24,28
	brne L2
;     {
;         rx_buffer1[rx_wr_index1]=data;
	ldi R24,<_rx_buffer1
	ldi R25,>_rx_buffer1
	lds R30,_rx_wr_index1
	clr R31
	add R30,R24
	adc R31,R25
	std z+0,R16
;         if (++rx_wr_index1 == RX_BUFFER_SIZE1)
	lds R24,_rx_wr_index1
	subi R24,255    ; addi 1
	mov R2,R24
	sts _rx_wr_index1,R2
	cpi R24,2
	brne L4
; 	    rx_wr_index1=0;
	clr R2
	sts _rx_wr_index1,R2
L4:
;         if (++rx_counter1 == RX_BUFFER_SIZE1)
	lds R24,_rx_counter1
	subi R24,255    ; addi 1
	mov R2,R24
	sts _rx_counter1,R2
	cpi R24,2
	brne L6
;         {
;             rx_counter1=0;
	clr R2
	sts _rx_counter1,R2
;             rx_buffer_overflow1=1;
	ldi R24,1
	sts _rx_buffer_overflow1,R24
;         }
L6:
;     }
L2:
L1:
	ld R2,y+
	out 0x3f,R2
	ld R31,y+
	ld R30,y+
	ld R25,y+
	ld R24,y+
	ld R18,y+
	ld R16,y+
	ld R2,y+
	.dbline 0 ; func end
	reti
	.area vector(rom, abs)
	.org 128
	jmp _uart1_tx_isr
	.area text(rom, con, rel)
	.even
_uart1_tx_isr::
	st -y,R2
	st -y,R24
	st -y,R25
	st -y,R30
	st -y,R31
	in R2,0x3f
	st -y,R2
; }
; 
; 
; #pragma interrupt_handler uart1_tx_isr:33
; void uart1_tx_isr(void)
; {
;     if (tx_counter1)
	lds R2,_tx_counter1
	tst R2
	breq L9
;     {
;         --tx_counter1;
	mov R24,R2
	subi R24,1
	sts _tx_counter1,R24
;         UDR1=tx_buffer1[tx_rd_index1];
	ldi R24,<_tx_buffer1
	ldi R25,>_tx_buffer1
	lds R30,_tx_rd_index1
	clr R31
	add R30,R24
	adc R31,R25
	ldd R2,z+0
	sts 156,R2
;         if (++tx_rd_index1 == TX_BUFFER_SIZE1)
	lds R24,_tx_rd_index1
	subi R24,255    ; addi 1
	mov R2,R24
	sts _tx_rd_index1,R2
	cpi R24,4
	brne L11
; 	    tx_rd_index1=0;
	clr R2
	sts _tx_rd_index1,R2
L11:
;     }
L9:
L8:
	ld R2,y+
	out 0x3f,R2
	ld R31,y+
	ld R30,y+
	ld R25,y+
	ld R24,y+
	ld R2,y+
	.dbline 0 ; func end
	reti
;              c -> R16
	.even
_putchar1::
; }
; 
; //#pragma used+
; void putchar1(INT8U c)
; {
L14:
L15:
;     while (tx_counter1 == TX_BUFFER_SIZE1);
	lds R24,_tx_counter1
	cpi R24,4
	breq L14
;     asm("cli");
	cli
;     if (tx_counter1 || ((UCSR1A & DATA_REGISTER_EMPTY)==0))
	tst R24
	brne L19
	lds R2,155
	sbrc R2,5
	rjmp L17
L19:
;     {
;         tx_buffer1[tx_wr_index1]=c;
	ldi R24,<_tx_buffer1
	ldi R25,>_tx_buffer1
	lds R30,_tx_wr_index1
	clr R31
	add R30,R24
	adc R31,R25
	std z+0,R16
;         if (++tx_wr_index1 == TX_BUFFER_SIZE1) 
	lds R24,_tx_wr_index1
	subi R24,255    ; addi 1
	mov R2,R24
	sts _tx_wr_index1,R2
	cpi R24,4
	brne L20
; 	    tx_wr_index1=0;
	clr R2
	sts _tx_wr_index1,R2
L20:
;         ++tx_counter1;
	lds R24,_tx_counter1
	subi R24,255    ; addi 1
	sts _tx_counter1,R24
;     }
	xjmp L18
L17:
;     else
;         UDR1=c;
	sts 156,R16
L18:
;     asm("sei");
	sei
L13:
	.dbline 0 ; func end
	ret
;           data -> R16
	.even
_getchar1::
; }
; //#pragma used-
; 
; //#pragma used+
; INT8U getchar1(void)
; {
L23:
L24:
;     INT8U data;
;     
;     while (rx_counter1==0);
	lds R2,_rx_counter1
	tst R2
	breq L23
;     data=rx_buffer1[rx_rd_index1];
	ldi R24,<_rx_buffer1
	ldi R25,>_rx_buffer1
	lds R30,_rx_rd_index1
	clr R31
	add R30,R24
	adc R31,R25
	ldd R16,z+0
;     if (++rx_rd_index1 == RX_BUFFER_SIZE1) 
	lds R24,_rx_rd_index1
	subi R24,255    ; addi 1
	mov R2,R24
	sts _rx_rd_index1,R2
	cpi R24,2
	brne L26
;         rx_rd_index1=0;
	clr R2
	sts _rx_rd_index1,R2
L26:
;     asm("cli");
	cli
;     --rx_counter1;
	lds R24,_rx_counter1
	subi R24,1
	sts _rx_counter1,R24
;     asm("sei");
	sei
;     return data;
L22:
	.dbline 0 ; func end
	ret
	.even
_Uart1_Init::
; }
; //#pragma used-
; 
; void Uart1_Init(void)
; { 
; // USART1 initialization
; // Communication Parameters: 8 Data, 1 Stop, No Parity
; // USART1 Receiver: On
; // USART1 Transmitter: On
; // USART1 Mode: Asynchronous
; // USART1 Baud rate: 38400  16M osc
;     UCSR1A=0x00;
	clr R2
	sts 155,R2
;     UCSR1B=0xD8;
	ldi R24,216
	sts 154,R24
;     UCSR1C=0x06;
	ldi R24,6
	sts 157,R24
;     
;     UBRR1H=0x00;
	sts 152,R2
;     UBRR1L=0x19;
	ldi R24,25
	sts 153,R24
L28:
	.dbline 0 ; func end
	ret
;             pt -> R20,R21
	.even
_Uart1_SendString::
	xcall push_gset1
	movw R20,R16
; }
; 
; void Uart1_SendString(INT8U *pt)
; {
	xjmp L31
L30:
	movw R30,R20
	ld R16,Z+
	movw R20,R30
	xcall _putchar1
L31:
;     while(*pt)
	movw R30,R20
	ldd R2,z+0
	tst R2
	brne L30
L29:
	xcall pop_gset1
	.dbline 0 ; func end
	ret
;          temp2 -> R20
;          temp1 -> R22
;            Hex -> R20
	.even
_PUT_INT8U_HexTOString::
	xcall push_gset2
	mov R20,R16
;     {
;         putchar1(*pt++);
;     }
; }
; 
; 
; //格式转换函数，十六进制转换为字符串  eg:输入0x5A，输出5A  
; void PUT_INT8U_HexTOString(INT8U Hex)
; {
;     INT8U temp1,temp2;
;     
;     temp1=(Hex>>4)&0x0F;
	mov R22,R20
	swap R22
	andi R22,#0x0F
	andi R22,15
;     temp2=Hex&0x0F;
	andi R20,15
;     
;     if(temp1<10)
	cpi R22,10
	brsh L34
;         putchar1(temp1+'0');
	mov R16,R22
	subi R16,208    ; addi 48
	xcall _putchar1
	xjmp L35
L34:
;     else
;         putchar1(temp1-10+'A');
	mov R16,R22
	subi R16,10
	subi R16,191    ; addi 65
	xcall _putchar1
L35:
; 	
;     if(temp2<10)
	cpi R20,10
	brsh L36
;         putchar1(temp2+'0');
	mov R16,R20
	subi R16,208    ; addi 48
	xcall _putchar1
	xjmp L37
L36:
;     else
;         putchar1(temp2-10+'A'); 
	mov R16,R20
	subi R16,10
	subi R16,191    ; addi 65
	xcall _putchar1
L37:
L33:
	xcall pop_gset2
	.dbline 0 ; func end
	ret
;         buffer -> y+4
;        temp32U -> y+0
;         temp8S -> R10
;            Dec -> y+21
	.even
_PUT_INT32U_DecTOString::
	xcall push_arg4
	xcall push_gset3
	sbiw R28,15
; }
; 
; //格式转换函数，十进制数据转换为字符串 eg：输入001234，串口输出1234(去掉无效0)
; void PUT_INT32U_DecTOString(INT32U Dec)
; {
;     INT8S temp8S ;
;     INT32U temp32U ;
;     INT8U buffer[11];
;     
;     temp32U=Dec ;
	movw R30,R28
	ldd R2,z+21
	ldd R3,z+22
	ldd R4,z+23
	ldd R5,z+24
	movw R30,R28
	std z+0,R2
	std z+1,R3
	std z+2,R4
	std z+3,R5
;     for(temp8S=10;temp8S>=0;temp8S--)
	ldi R24,10
	mov R10,R24
	xjmp L42
L39:
	ldi R20,10
	ldi R21,0
	ldi R22,0
	ldi R23,0
	movw R30,R28
	ldd R2,z+0
	ldd R3,z+1
	ldd R4,z+2
	ldd R5,z+3
	st -y,R23
	st -y,R22
	st -y,R21
	st -y,R20
	movw R16,R2
	movw R18,R4
	xcall mod32u
	movw R2,R16
	movw R4,R18
	ldi R20,48
	ldi R21,0
	ldi R22,0
	ldi R23,0
	add R2,R20
	adc R3,R21
	adc R4,R22
	adc R5,R23
	movw R24,R28
	adiw R24,4
	mov R30,R10
	clr R31
	sbrc R30,7
	com R31
	add R30,R24
	adc R31,R25
	std z+0,R2
	ldi R20,10
	ldi R21,0
	ldi R22,0
	ldi R23,0
	movw R30,R28
	ldd R2,z+0
	ldd R3,z+1
	ldd R4,z+2
	ldd R5,z+3
	st -y,R23
	st -y,R22
	st -y,R21
	st -y,R20
	movw R16,R2
	movw R18,R4
	xcall div32u
	movw R30,R28
	std z+0,R16
	std z+1,R17
	std z+2,R18
	std z+3,R19
L40:
	dec R10
L42:
	mov R24,R10
	cpi R24,0
	brlt X0
	xjmp L39
X0:
;     {
;         buffer[temp8S]=temp32U%10+'0' ;
;         temp32U=temp32U/10 ;
;     }
;     buffer[11]='\0' ;
	clr R2
	std y+15,R2
;     
;     if(buffer[0]=='0')
	ldd R24,y+4
	cpi R24,48
	breq X1
	xjmp L44
X1:
;     {
;         if(buffer[1]=='0')
	ldd R24,y+5
	cpi R24,48
	breq X2
	xjmp L46
X2:
;         {
;             if(buffer[2]=='0')
	ldd R24,y+6
	cpi R24,48
	breq X3
	xjmp L49
X3:
;             {
;                 if(buffer[3]=='0')
	ldd R24,y+7
	cpi R24,48
	breq X4
	xjmp L52
X4:
;                 {
;                     if(buffer[4]=='0')
	ldd R24,y+8
	cpi R24,48
	brne L55
;                     {
;                         if(buffer[5]=='0')
	ldd R24,y+9
	cpi R24,48
	brne L58
;                         {
;                             if(buffer[6]=='0')
	ldd R24,y+10
	cpi R24,48
	brne L61
;                             {