main.lss

AVR Mega88 + nRF24L01 wireless 2.4GHz >> Driver nRF24L01 >> AVRSTUDIO project

    tmphead  = (USART_TxHead + 1) & USART_TX_BUFFER_MASK;
 1d6:	90 91 b3 01 	lds	r25, 0x01B3
 1da:	9f 5f       	subi	r25, 0xFF	; 255
 1dc:	9f 71       	andi	r25, 0x1F	; 31
    
    while ( tmphead == USART_TxTail ){
 1de:	80 91 b4 01 	lds	r24, 0x01B4
 1e2:	98 17       	cp	r25, r24
 1e4:	e1 f3       	breq	.-8      	; 0x1de <usart_putc+0xa>
        ;
    }
    
    USART_TxBuf[tmphead] = data;
 1e6:	e9 2f       	mov	r30, r25
 1e8:	ff 27       	eor	r31, r31
 1ea:	ed 56       	subi	r30, 0x6D	; 109
 1ec:	fe 4f       	sbci	r31, 0xFE	; 254
 1ee:	20 83       	st	Z, r18
    USART_TxHead = tmphead;
 1f0:	90 93 b3 01 	sts	0x01B3, r25
    USART_CONTROL |= (1<<UDRIE0);
 1f4:	80 91 c1 00 	lds	r24, 0x00C1
 1f8:	80 62       	ori	r24, 0x20	; 32
 1fa:	80 93 c1 00 	sts	0x00C1, r24
 1fe:	08 95       	ret

00000200 <usart_puts_p>:
 200:	cf 93       	push	r28
 202:	df 93       	push	r29
 204:	ec 01       	movw	r28, r24
 206:	01 c0       	rjmp	.+2      	; 0x20a <usart_puts_p+0xa>
 208:	e5 df       	rcall	.-54     	; 0x1d4 <usart_putc>
 20a:	fe 01       	movw	r30, r28
 20c:	21 96       	adiw	r28, 0x01	; 1
 20e:	84 91       	lpm	r24, Z
 210:	88 23       	and	r24, r24
 212:	d1 f7       	brne	.-12     	; 0x208 <usart_puts_p+0x8>
 214:	df 91       	pop	r29
 216:	cf 91       	pop	r28
 218:	08 95       	ret

0000021a <usart_puts>:
 21a:	cf 93       	push	r28
 21c:	df 93       	push	r29
 21e:	ec 01       	movw	r28, r24
 220:	02 c0       	rjmp	.+4      	; 0x226 <usart_puts+0xc>
 222:	21 96       	adiw	r28, 0x01	; 1
 224:	d7 df       	rcall	.-82     	; 0x1d4 <usart_putc>
 226:	88 81       	ld	r24, Y
 228:	88 23       	and	r24, r24
 22a:	d9 f7       	brne	.-10     	; 0x222 <usart_puts+0x8>
 22c:	df 91       	pop	r29
 22e:	cf 91       	pop	r28
 230:	08 95       	ret

00000232 <DataInReceiveBuffer>:
}

int DataInReceiveBuffer( void )
{
 232:	90 91 91 01 	lds	r25, 0x0191
 236:	80 91 92 01 	lds	r24, 0x0192
 23a:	20 e0       	ldi	r18, 0x00	; 0
 23c:	30 e0       	ldi	r19, 0x00	; 0
 23e:	98 17       	cp	r25, r24
 240:	11 f0       	breq	.+4      	; 0x246 <DataInReceiveBuffer+0x14>
	return ( USART_RxHead != USART_RxTail ); /* Return 0 (FALSE) if the receive buffer is empty */
 242:	21 e0       	ldi	r18, 0x01	; 1
 244:	30 e0       	ldi	r19, 0x00	; 0
}
 246:	c9 01       	movw	r24, r18
 248:	08 95       	ret

0000024a <usart_ready>:

unsigned  int  usart_ready(void)
{
 24a:	90 91 91 01 	lds	r25, 0x0191
 24e:	80 91 92 01 	lds	r24, 0x0192
 252:	20 e0       	ldi	r18, 0x00	; 0
 254:	98 17       	cp	r25, r24
 256:	09 f4       	brne	.+2      	; 0x25a <usart_ready+0x10>

	if ( USART_RxHead == USART_RxTail ) 
 258:	21 e0       	ldi	r18, 0x01	; 1
 25a:	81 e0       	ldi	r24, 0x01	; 1
 25c:	28 27       	eor	r18, r24
   		return(FALSE);
	else
   		return(TRUE);
}
 25e:	82 2f       	mov	r24, r18
 260:	99 27       	eor	r25, r25
 262:	08 95       	ret

00000264 <usart_SendBcd>:


void usart_SendBcd(unsigned char hexIn)
{
 264:	0f 93       	push	r16
 266:	1f 93       	push	r17
 268:	cf 93       	push	r28
 26a:	df 93       	push	r29
 26c:	cd b7       	in	r28, 0x3d	; 61
 26e:	de b7       	in	r29, 0x3e	; 62
 270:	21 97       	sbiw	r28, 0x01	; 1
 272:	0f b6       	in	r0, 0x3f	; 63
 274:	f8 94       	cli
 276:	de bf       	out	0x3e, r29	; 62
 278:	0f be       	out	0x3f, r0	; 63
 27a:	cd bf       	out	0x3d, r28	; 61
 27c:	98 2f       	mov	r25, r24
	unsigned char tempHex;

	tempHex = hexDigits[hexIn >> 4];
 27e:	82 95       	swap	r24
 280:	8f 70       	andi	r24, 0x0F	; 15
 282:	06 e1       	ldi	r16, 0x16	; 22
 284:	11 e0       	ldi	r17, 0x01	; 1
 286:	f8 01       	movw	r30, r16
 288:	e8 0f       	add	r30, r24
 28a:	f1 1d       	adc	r31, r1
 28c:	80 81       	ld	r24, Z
	usart_putc(tempHex);
 28e:	99 83       	std	Y+1, r25	; 0x01
 290:	a1 df       	rcall	.-190    	; 0x1d4 <usart_putc>
	tempHex = hexDigits[hexIn & 0x0F]; 
 292:	99 81       	ldd	r25, Y+1	; 0x01
 294:	9f 70       	andi	r25, 0x0F	; 15
 296:	09 0f       	add	r16, r25
 298:	11 1d       	adc	r17, r1
 29a:	f8 01       	movw	r30, r16
 29c:	80 81       	ld	r24, Z
	usart_putc(tempHex);	   
 29e:	9a df       	rcall	.-204    	; 0x1d4 <usart_putc>
 2a0:	21 96       	adiw	r28, 0x01	; 1
 2a2:	0f b6       	in	r0, 0x3f	; 63
 2a4:	f8 94       	cli
 2a6:	de bf       	out	0x3e, r29	; 62
 2a8:	0f be       	out	0x3f, r0	; 63
 2aa:	cd bf       	out	0x3d, r28	; 61
 2ac:	df 91       	pop	r29
 2ae:	cf 91       	pop	r28
 2b0:	1f 91       	pop	r17
 2b2:	0f 91       	pop	r16
 2b4:	08 95       	ret

000002b6 <delayloop>:
#include <util/delay.h>
#include "delay.h"

void delayloop(unsigned long t) 
{
 2b6:	08 95       	ret

000002b8 <delay_ms>:
	unsigned int i;
	if (t==0) return;
	while (t--) for(i=0;i<K_DELAY; i++);
}

void delay_ms(unsigned long  ms) 
{ 
 2b8:	ef 92       	push	r14
 2ba:	ff 92       	push	r15
 2bc:	0f 93       	push	r16
 2be:	1f 93       	push	r17
 2c0:	7b 01       	movw	r14, r22
 2c2:	8c 01       	movw	r16, r24
 2c4:	20 e0       	ldi	r18, 0x00	; 0
 2c6:	30 e0       	ldi	r19, 0x00	; 0
 2c8:	40 e0       	ldi	r20, 0x00	; 0
 2ca:	50 e0       	ldi	r21, 0x00	; 0
 2cc:	ec ec       	ldi	r30, 0xCC	; 204
 2ce:	fa e0       	ldi	r31, 0x0A	; 10
 2d0:	07 c0       	rjmp	.+14     	; 0x2e0 <delay_ms+0x28>
 */
void
_delay_loop_2(uint16_t __count)
{
	__asm__ volatile (
 2d2:	cf 01       	movw	r24, r30
 2d4:	01 97       	sbiw	r24, 0x01	; 1
 2d6:	f1 f7       	brne	.-4      	; 0x2d4 <delay_ms+0x1c>
    unsigned long i; 
    for (i=0; i < ms; i++) 
 2d8:	2f 5f       	subi	r18, 0xFF	; 255
 2da:	3f 4f       	sbci	r19, 0xFF	; 255
 2dc:	4f 4f       	sbci	r20, 0xFF	; 255
 2de:	5f 4f       	sbci	r21, 0xFF	; 255
 2e0:	2e 15       	cp	r18, r14
 2e2:	3f 05       	cpc	r19, r15
 2e4:	40 07       	cpc	r20, r16
 2e6:	51 07       	cpc	r21, r17
 2e8:	a1 f7       	brne	.-24     	; 0x2d2 <delay_ms+0x1a>
 2ea:	1f 91       	pop	r17
 2ec:	0f 91       	pop	r16
 2ee:	ff 90       	pop	r15
 2f0:	ef 90       	pop	r14
 2f2:	08 95       	ret

000002f4 <delay_us>:
    { 
        _delay_ms(1); 
    } 
} 

void delay_us(unsigned int  us) 
{ 
 2f4:	ac 01       	movw	r20, r24
 2f6:	20 e0       	ldi	r18, 0x00	; 0
 2f8:	30 e0       	ldi	r19, 0x00	; 0
 2fa:	93 e0       	ldi	r25, 0x03	; 3
 2fc:	05 c0       	rjmp	.+10     	; 0x308 <delay_us+0x14>
*/
void
_delay_loop_1(uint8_t __count)
{
	__asm__ volatile (
 2fe:	89 2f       	mov	r24, r25
 300:	8a 95       	dec	r24
 302:	f1 f7       	brne	.-4      	; 0x300 <delay_us+0xc>
 304:	2f 5f       	subi	r18, 0xFF	; 255
 306:	3f 4f       	sbci	r19, 0xFF	; 255
    unsigned long i; 
	
    for (i=0; i < us; i++) 
 308:	24 17       	cp	r18, r20
 30a:	35 07       	cpc	r19, r21
 30c:	c1 f7       	brne	.-16     	; 0x2fe <delay_us+0xa>
 30e:	08 95       	ret

00000310 <__vector_16>:

volatile unsigned int CountMilliseconds = 0;

SIGNAL(SIG_OVERFLOW0)
{
 310:	1f 92       	push	r1
 312:	0f 92       	push	r0
 314:	0f b6       	in	r0, 0x3f	; 63
 316:	0f 92       	push	r0
 318:	11 24       	eor	r1, r1
 31a:	2f 93       	push	r18
 31c:	8f 93       	push	r24
 31e:	9f 93       	push	r25

 TCNT0 -= INTS_PER_milSECOND;
 320:	86 b5       	in	r24, 0x26	; 38
 322:	86 51       	subi	r24, 0x16	; 22
 324:	86 bd       	out	0x26, r24	; 38
 
 CountMilliseconds = milseconds;
 326:	80 91 b7 01 	lds	r24, 0x01B7
 32a:	90 91 b8 01 	lds	r25, 0x01B8
 32e:	90 93 b6 01 	sts	0x01B6, r25
 332:	80 93 b5 01 	sts	0x01B5, r24

 if(milseconds>=65535)
 336:	2f ef       	ldi	r18, 0xFF	; 255
 338:	8f 3f       	cpi	r24, 0xFF	; 255
 33a:	92 07       	cpc	r25, r18
 33c:	29 f4       	brne	.+10     	; 0x348 <__vector_16+0x38>
 {
 	milseconds=0;
 33e:	10 92 b8 01 	sts	0x01B8, r1
 342:	10 92 b7 01 	sts	0x01B7, r1
 346:	05 c0       	rjmp	.+10     	; 0x352 <__vector_16+0x42>
 }else
    milseconds++;
 348:	01 96       	adiw	r24, 0x01	; 1
 34a:	90 93 b8 01 	sts	0x01B8, r25
 34e:	80 93 b7 01 	sts	0x01B7, r24
 352:	9f 91       	pop	r25
 354:	8f 91       	pop	r24
 356:	2f 91       	pop	r18
 358:	0f 90       	pop	r0
 35a:	0f be       	out	0x3f, r0	; 63
 35c:	0f 90       	pop	r0
 35e:	1f 90       	pop	r1
 360:	18 95       	reti

00000362 <Timer0_Init>:
 
 
}

enum {
  STOP             = 0,
  CK               = 1,
  CK8              = 2,
  CK64             = 3,
  CK256            = 4,
  CK1024           = 5,
  T0_FALLING_EDGE  = 6,
  T0_RISING_EDGE   = 7
};

void Timer0_Init(void)
{
 362:	85 e0       	ldi	r24, 0x05	; 5
 364:	85 bd       	out	0x25, r24	; 37
// Timer/Counter 0 initialization
// (for system Clock = 12.000.000)
// Clock source: System Clock
// Mode: Normal top=FFh
// OC0 output: Disconnected
 TCCR0B = CK1024;
 TCNT0 = INTS_PER_milSECOND;  // reload
 366:	86 e1       	ldi	r24, 0x16	; 22
 368:	86 bd       	out	0x26, r24	; 38

//   12000000/1024 = 11718.75
//   Fosc / second  =  1/11718.75 = 85.3us
//   caculate 1ms reload (1/1000)/64us = 0.001/(85.3*10-6) = 11.7 ~ 12
//   TCNT0 = 12 for timer0 count 1ms        
//   default  INTS_PER_milSECOND = 12

// OCR0  = 0x00;
// Tier(s)/Counter(s) Interrupt(s) initialization
 TIMSK0 |= 0x01;
 36a:	ee e6       	ldi	r30, 0x6E	; 110
 36c:	f0 e0       	ldi	r31, 0x00	; 0
 36e:	80 81       	ld	r24, Z
 370:	81 60       	ori	r24, 0x01	; 1
 372:	80 83       	st	Z, r24
 374:	08 95       	ret

00000376 <SPI_SendByte>:
    return 1;
}

unsigned char SPI_SendByte(unsigned char DataIn)
{        
 376:	8e bd       	out	0x2e, r24	; 46
    // Start transmission
    SPDR = DataIn;      
                 
    // Wait for transmission complete
    while (!(SPSR & (1<<SPIF)))   
 378:	0d b4       	in	r0, 0x2d	; 45
 37a:	07 fe       	sbrs	r0, 7
 37c:	fd cf       	rjmp	.-6      	; 0x378 <SPI_SendByte+0x2>
        ;

    return SPDR;
 37e:	8e b5       	in	r24, 0x2e	; 46
}
 380:	99 27       	eor	r25, r25
 382:	08 95       	ret

00000384 <SPI_MasterInit>:

void SPI_MasterInit(void)