main.lss

AVR单片机软件模拟串口实现全双工的例子。

 222:	c8 f1       	brcs	.+114    	; 0x296 <__vector_9+0x126>
					// overflow - rst inbuf-index
					qin = 0;
 224:	10 92 6e 00 	sts	0x006E, r1
 228:	36 c0       	rjmp	.+108    	; 0x296 <__vector_9+0x126>
				}
			}
		}
		else {  // rx_test_busy
			if ( flag_rx_ready == SU_FALSE ) {
 22a:	80 91 96 00 	lds	r24, 0x0096
 22e:	88 23       	and	r24, r24
 230:	81 f4       	brne	.+32     	; 0x252 <__vector_9+0xe2>
				start_bit = get_rx_pin_status();
				// test for start bit
				if ( start_bit == 0 ) {
 232:	86 99       	sbic	0x10, 6	; 16
 234:	30 c0       	rjmp	.+96     	; 0x296 <__vector_9+0x126>
					flag_rx_ready      = SU_TRUE;
 236:	81 e0       	ldi	r24, 0x01	; 1
 238:	80 93 96 00 	sts	0x0096, r24
					internal_rx_buffer = 0;
 23c:	10 92 70 00 	sts	0x0070, r1
					timer_rx_ctr       = 4;
 240:	94 e0       	ldi	r25, 0x04	; 4
 242:	90 93 72 00 	sts	0x0072, r25
					bits_left_in_rx    = RX_NUM_OF_BITS;
 246:	98 e0       	ldi	r25, 0x08	; 8
 248:	90 93 71 00 	sts	0x0071, r25
					rx_mask            = 1;
 24c:	80 93 73 00 	sts	0x0073, r24
 250:	22 c0       	rjmp	.+68     	; 0x296 <__vector_9+0x126>
				}
			}
			else {  // rx_busy
				if ( --timer_rx_ctr <= 0 ) {
 252:	80 91 72 00 	lds	r24, 0x0072
 256:	81 50       	subi	r24, 0x01	; 1
 258:	80 93 72 00 	sts	0x0072, r24
 25c:	88 23       	and	r24, r24
 25e:	d9 f4       	brne	.+54     	; 0x296 <__vector_9+0x126>
					// rcv
					timer_rx_ctr = 3;
 260:	83 e0       	ldi	r24, 0x03	; 3
 262:	80 93 72 00 	sts	0x0072, r24
					flag_in = get_rx_pin_status();
					if ( flag_in ) {
 266:	86 9b       	sbis	0x10, 6	; 16
 268:	07 c0       	rjmp	.+14     	; 0x278 <__vector_9+0x108>
						internal_rx_buffer |= rx_mask;
 26a:	80 91 70 00 	lds	r24, 0x0070
 26e:	90 91 73 00 	lds	r25, 0x0073
 272:	89 2b       	or	r24, r25
 274:	80 93 70 00 	sts	0x0070, r24
					}
					rx_mask <<= 1;
 278:	80 91 73 00 	lds	r24, 0x0073
 27c:	88 0f       	add	r24, r24
 27e:	80 93 73 00 	sts	0x0073, r24
					if ( --bits_left_in_rx <= 0 ) {
 282:	80 91 71 00 	lds	r24, 0x0071
 286:	81 50       	subi	r24, 0x01	; 1
 288:	80 93 71 00 	sts	0x0071, r24
 28c:	88 23       	and	r24, r24
 28e:	19 f4       	brne	.+6      	; 0x296 <__vector_9+0x126>
						flag_rx_waiting_for_stop_bit = SU_TRUE;
 290:	81 e0       	ldi	r24, 0x01	; 1
 292:	80 93 74 00 	sts	0x0074, r24
 296:	ff 91       	pop	r31
 298:	ef 91       	pop	r30
 29a:	9f 91       	pop	r25
 29c:	8f 91       	pop	r24
 29e:	0f 90       	pop	r0
 2a0:	0f be       	out	0x3f, r0	; 63
 2a2:	0f 90       	pop	r0
 2a4:	1f 90       	pop	r1
 2a6:	18 95       	reti

000002a8 <softuart_init>:
					}
				}
			}
		}
	}
}

static void avr_io_init(void)
{
	// TX-Pin as output
	SOFTUART_TXDDR |=  ( 1 << SOFTUART_TXBIT ); //PD7-OUT
	// RX-Pin as input
	SOFTUART_RXDDR &= ~( 1 << SOFTUART_RXBIT ); //PD6-IN
}

static void avr_timer_init(void)
{
	unsigned char sreg_tmp;
	
	sreg_tmp = SREG;
	cli();
	
	//SOFTUART_T_COMP_REG = SOFTUART_TIMERTOP;     /* set top */

	//SOFTUART_T_CONTR_REGA = SOFTUART_CTC_MASKA | SOFTUART_PRESC_MASKA;
	//SOFTUART_T_CONTR_REGB = SOFTUART_CTC_MASKB | SOFTUART_PRESC_MASKB;
    SOFTUART_T_CONTR_REG = SOFTUART_PRESC_MASK; //8分频
	SOFTUART_T_INTCTL_REG |= SOFTUART_CMPINT_EN_MASK;

	SOFTUART_T_CNT_REG = 0; /* reset counter */
	
	SREG = sreg_tmp;
}

void softuart_init( void )
{
 2a8:	10 92 97 00 	sts	0x0097, r1
	flag_tx_ready = SU_FALSE;
	flag_rx_ready = SU_FALSE;
 2ac:	10 92 96 00 	sts	0x0096, r1
	flag_rx_off   = SU_FALSE;
 2b0:	10 92 95 00 	sts	0x0095, r1
	
	set_tx_pin_high(); /* mt: set to high to avoid garbage on init */
 2b4:	97 9a       	sbi	0x12, 7	; 18
 2b6:	8f 9a       	sbi	0x11, 7	; 17
 2b8:	8e 98       	cbi	0x11, 6	; 17
 2ba:	9f b7       	in	r25, 0x3f	; 63
 2bc:	f8 94       	cli
 2be:	82 e0       	ldi	r24, 0x02	; 2
 2c0:	83 bf       	out	0x33, r24	; 51
 2c2:	89 b7       	in	r24, 0x39	; 57
 2c4:	81 60       	ori	r24, 0x01	; 1
 2c6:	89 bf       	out	0x39, r24	; 57
 2c8:	12 be       	out	0x32, r1	; 50
 2ca:	9f bf       	out	0x3f, r25	; 63
 2cc:	08 95       	ret

000002ce <softuart_turn_rx_on>:
	avr_io_init();

	// timer_set( BAUD_RATE );
	// set_timer_interrupt( timer_isr );
	avr_timer_init(); // replaces the two calls above
}

static void idle(void)
{
	// timeout handling goes here 
	// - but there is a "softuart_kbhit" in this code...
	// add watchdog-reset here if needed
}

void softuart_turn_rx_on( void )
{
 2ce:	10 92 95 00 	sts	0x0095, r1
 2d2:	08 95       	ret

000002d4 <softuart_turn_rx_off>:
	flag_rx_off = SU_FALSE;
}

void softuart_turn_rx_off( void )
{
 2d4:	81 e0       	ldi	r24, 0x01	; 1
 2d6:	80 93 95 00 	sts	0x0095, r24
 2da:	08 95       	ret

000002dc <softuart_getchar>:
	flag_rx_off = SU_TRUE;
}

char softuart_getchar( void )
{
 2dc:	20 91 6f 00 	lds	r18, 0x006F
	char ch;

	while ( qout == qin ) {
 2e0:	80 91 6e 00 	lds	r24, 0x006E
 2e4:	28 17       	cp	r18, r24
 2e6:	e1 f3       	breq	.-8      	; 0x2e0 <softuart_getchar+0x4>
		idle();
	}
	ch = inbuf[qout];
 2e8:	e2 2f       	mov	r30, r18
 2ea:	ff 27       	eor	r31, r31
 2ec:	eb 58       	subi	r30, 0x8B	; 139
 2ee:	ff 4f       	sbci	r31, 0xFF	; 255
 2f0:	e0 81       	ld	r30, Z
	if ( ++qout >= SOFTUART_IN_BUF_SIZE ) {
 2f2:	82 2f       	mov	r24, r18
 2f4:	8f 5f       	subi	r24, 0xFF	; 255
 2f6:	80 93 6f 00 	sts	0x006F, r24
 2fa:	80 32       	cpi	r24, 0x20	; 32
 2fc:	10 f0       	brcs	.+4      	; 0x302 <softuart_getchar+0x26>
		qout = 0;
 2fe:	10 92 6f 00 	sts	0x006F, r1
	}
	
	return( ch );
}
 302:	8e 2f       	mov	r24, r30
 304:	99 27       	eor	r25, r25
 306:	08 95       	ret

00000308 <softuart_kbhit>:

unsigned char softuart_kbhit( void )
{
 308:	90 91 6e 00 	lds	r25, 0x006E
 30c:	20 e0       	ldi	r18, 0x00	; 0
 30e:	30 e0       	ldi	r19, 0x00	; 0
 310:	80 91 6f 00 	lds	r24, 0x006F
 314:	98 17       	cp	r25, r24
 316:	11 f0       	breq	.+4      	; 0x31c <softuart_kbhit+0x14>
	return( qin != qout );
 318:	21 e0       	ldi	r18, 0x01	; 1
 31a:	30 e0       	ldi	r19, 0x00	; 0
}
 31c:	c9 01       	movw	r24, r18
 31e:	08 95       	ret

00000320 <softuart_flush_input_buffer>:

void softuart_flush_input_buffer( void )
{
 320:	10 92 6e 00 	sts	0x006E, r1
	qin  = 0;
	qout = 0;
 324:	10 92 6f 00 	sts	0x006F, r1
 328:	08 95       	ret

0000032a <softuart_can_transmit>:
}
	
unsigned char softuart_can_transmit( void ) 
{
 32a:	80 91 97 00 	lds	r24, 0x0097
	return ( flag_tx_ready );
}
 32e:	99 27       	eor	r25, r25
 330:	08 95       	ret

00000332 <softuart_putchar>:

void softuart_putchar( const char ch )
{
 332:	98 2f       	mov	r25, r24
	while ( flag_tx_ready ) {
 334:	80 91 97 00 	lds	r24, 0x0097
 338:	88 23       	and	r24, r24
 33a:	e1 f7       	brne	.-8      	; 0x334 <softuart_putchar+0x2>
		; // wait for transmitter ready
		  // add watchdog-reset here if needed;
	}

	// invoke_UART_transmit
	timer_tx_ctr       = 3;
 33c:	83 e0       	ldi	r24, 0x03	; 3
 33e:	80 93 98 00 	sts	0x0098, r24
	bits_left_in_tx    = TX_NUM_OF_BITS;
 342:	8a e0       	ldi	r24, 0x0A	; 10
 344:	80 93 99 00 	sts	0x0099, r24
	internal_tx_buffer = ( ch<<1 ) | 0x200;
 348:	89 2f       	mov	r24, r25
 34a:	99 27       	eor	r25, r25
 34c:	88 0f       	add	r24, r24
 34e:	99 1f       	adc	r25, r25
 350:	92 60       	ori	r25, 0x02	; 2
 352:	90 93 9b 00 	sts	0x009B, r25
 356:	80 93 9a 00 	sts	0x009A, r24
	flag_tx_ready      = SU_TRUE;
 35a:	81 e0       	ldi	r24, 0x01	; 1
 35c:	80 93 97 00 	sts	0x0097, r24
 360:	08 95       	ret

00000362 <softuart_puts>:
}
	
void softuart_puts( const char *s )
{
 362:	cf 93       	push	r28
 364:	df 93       	push	r29
 366:	ec 01       	movw	r28, r24
 368:	02 c0       	rjmp	.+4      	; 0x36e <softuart_puts+0xc>
	while ( *s ) {
		softuart_putchar( *s++ );
 36a:	21 96       	adiw	r28, 0x01	; 1
 36c:	e2 df       	rcall	.-60     	; 0x332 <softuart_putchar>
 36e:	88 81       	ld	r24, Y
 370:	88 23       	and	r24, r24
 372:	d9 f7       	brne	.-10     	; 0x36a <softuart_puts+0x8>
 374:	df 91       	pop	r29
 376:	cf 91       	pop	r28
 378:	08 95       	ret

0000037a <softuart_puts_p>:
	}
}
	
void softuart_puts_p( const char *prg_s )
{
 37a:	cf 93       	push	r28
 37c:	df 93       	push	r29
 37e:	ec 01       	movw	r28, r24
 380:	01 c0       	rjmp	.+2      	; 0x384 <softuart_puts_p+0xa>
	char c;

	while ( ( c = pgm_read_byte( prg_s++ ) ) ) {
		softuart_putchar(c);
 382:	d7 df       	rcall	.-82     	; 0x332 <softuart_putchar>
 384:	fe 01       	movw	r30, r28
 386:	21 96       	adiw	r28, 0x01	; 1
 388:	84 91       	lpm	r24, Z
 38a:	88 23       	and	r24, r24
 38c:	d1 f7       	brne	.-12     	; 0x382 <softuart_puts_p+0x8>
 38e:	df 91       	pop	r29
 390:	cf 91       	pop	r28
 392:	08 95       	ret

00000394 <gpio_init>:

#include "gpio.h"

void gpio_init(void)
{
 394:	88 b3       	in	r24, 0x18	; 24
 396:	8f ef       	ldi	r24, 0xFF	; 255
 398:	88 bb       	out	0x18, r24	; 24
    LEDPORT |= 0XFF;//( LED0 | LED1 | LED2 ); // all off
	LEDDDR  |= (LED1); // set as output
 39a:	b9 9a       	sbi	0x17, 1	; 23
 39c:	08 95       	ret

0000039e <gpio_set_led>:
}
	
void gpio_set_led(const uint8_t bitmask)
{
 39e:	98 b3       	in	r25, 0x18	; 24
 3a0:	80 95       	com	r24
 3a2:	98 23       	and	r25, r24
 3a4:	98 bb       	out	0x18, r25	; 24
 3a6:	08 95       	ret

000003a8 <gpio_clear_led>:
	LEDPORT &= ~(bitmask);
}

void gpio_clear_led(const uint8_t bitmask)
{
 3a8:	98 b3       	in	r25, 0x18	; 24
 3aa:	98 2b       	or	r25, r24
 3ac:	98 bb       	out	0x18, r25	; 24
 3ae:	08 95       	ret

000003b0 <gpio_toggle_led>:
	LEDPORT |= (bitmask);
}

void gpio_toggle_led(const uint8_t bitmask)
{
 3b0:	98 b3       	in	r25, 0x18	; 24
 3b2:	98 27       	eor	r25, r24
 3b4:	98 bb       	out	0x18, r25	; 24
 3b6:	08 95       	ret