lcd_pcd8544.lss

Nokia 6110 LCD 驱动 Atmega8

00000a84 <LcdImage>:
 * Argument(s)  :  Address of image in hexes
 * Return value :  None.
 * Example      :  LcdImage(&sample_image_declared_as_array);
 */
void LcdImage ( const byte *imageData )
{
 a84:	a0 e6       	ldi	r26, 0x60	; 96
 a86:	b0 e0       	ldi	r27, 0x00	; 0
 a88:	20 e0       	ldi	r18, 0x00	; 0
 a8a:	30 e0       	ldi	r19, 0x00	; 0
 a8c:	06 c0       	rjmp	.+12     	; 0xa9a <LcdImage+0x16>
	/* Initialize cache index to 0 */
	LcdCacheIdx = 0;
	/* While within cache range */
    for ( LcdCacheIdx = 0; LcdCacheIdx < LCD_CACHE_SIZE; LcdCacheIdx++ )
 a8e:	fc 01       	movw	r30, r24
    {
		/* Copy data from pointer to cache buffer */
        LcdCache[LcdCacheIdx] = pgm_read_byte( imageData++ );
 a90:	01 96       	adiw	r24, 0x01	; 1
 a92:	e4 91       	lpm	r30, Z+
 a94:	ed 93       	st	X+, r30
 a96:	2f 5f       	subi	r18, 0xFF	; 255
 a98:	3f 4f       	sbci	r19, 0xFF	; 255
void LcdImage ( const byte *imageData )
{
	/* Initialize cache index to 0 */
	LcdCacheIdx = 0;
	/* While within cache range */
    for ( LcdCacheIdx = 0; LcdCacheIdx < LCD_CACHE_SIZE; LcdCacheIdx++ )
 a9a:	41 e0       	ldi	r20, 0x01	; 1
 a9c:	28 3f       	cpi	r18, 0xF8	; 248
 a9e:	34 07       	cpc	r19, r20
 aa0:	b4 f3       	brlt	.-20     	; 0xa8e <LcdImage+0xa>
 aa2:	30 93 59 02 	sts	0x0259, r19
 aa6:	20 93 58 02 	sts	0x0258, r18
    {
		/* Copy data from pointer to cache buffer */
        LcdCache[LcdCacheIdx] = pgm_read_byte( imageData++ );
    }
	/* Reset watermark pointers to be full */
    LoWaterMark = 0;
 aaa:	10 92 5b 02 	sts	0x025B, r1
 aae:	10 92 5a 02 	sts	0x025A, r1
    HiWaterMark = LCD_CACHE_SIZE - 1;
 ab2:	87 ef       	ldi	r24, 0xF7	; 247
 ab4:	91 e0       	ldi	r25, 0x01	; 1
 ab6:	90 93 5d 02 	sts	0x025D, r25
 aba:	80 93 5c 02 	sts	0x025C, r24

	/* Set update flag to be true */
    UpdateLcd = TRUE;
 abe:	81 e0       	ldi	r24, 0x01	; 1
 ac0:	80 93 5e 02 	sts	0x025E, r24
}
 ac4:	08 95       	ret

00000ac6 <LcdUpdate>:
 * Description  :  Copies the LCD cache into the device RAM.
 * Argument(s)  :  None.
 * Return value :  None.
 */
void LcdUpdate ( void )
{
 ac6:	80 91 5a 02 	lds	r24, 0x025A
 aca:	90 91 5b 02 	lds	r25, 0x025B
 ace:	97 ff       	sbrs	r25, 7
 ad0:	05 c0       	rjmp	.+10     	; 0xadc <LcdUpdate+0x16>
    int i;

    if ( LoWaterMark < 0 )
        LoWaterMark = 0;
 ad2:	10 92 5b 02 	sts	0x025B, r1
 ad6:	10 92 5a 02 	sts	0x025A, r1
 ada:	09 c0       	rjmp	.+18     	; 0xaee <LcdUpdate+0x28>
    else if ( LoWaterMark >= LCD_CACHE_SIZE )
 adc:	88 5f       	subi	r24, 0xF8	; 248
 ade:	91 40       	sbci	r25, 0x01	; 1
 ae0:	34 f0       	brlt	.+12     	; 0xaee <LcdUpdate+0x28>
        LoWaterMark = LCD_CACHE_SIZE - 1;
 ae2:	87 ef       	ldi	r24, 0xF7	; 247
 ae4:	91 e0       	ldi	r25, 0x01	; 1
 ae6:	90 93 5b 02 	sts	0x025B, r25
 aea:	80 93 5a 02 	sts	0x025A, r24

    if ( HiWaterMark < 0 )
 aee:	80 91 5c 02 	lds	r24, 0x025C
 af2:	90 91 5d 02 	lds	r25, 0x025D
 af6:	97 ff       	sbrs	r25, 7
 af8:	05 c0       	rjmp	.+10     	; 0xb04 <LcdUpdate+0x3e>
        HiWaterMark = 0;
 afa:	10 92 5d 02 	sts	0x025D, r1
 afe:	10 92 5c 02 	sts	0x025C, r1
 b02:	09 c0       	rjmp	.+18     	; 0xb16 <LcdUpdate+0x50>
    else if ( HiWaterMark >= LCD_CACHE_SIZE )
 b04:	88 5f       	subi	r24, 0xF8	; 248
 b06:	91 40       	sbci	r25, 0x01	; 1
 b08:	34 f0       	brlt	.+12     	; 0xb16 <LcdUpdate+0x50>
        HiWaterMark = LCD_CACHE_SIZE - 1;
 b0a:	87 ef       	ldi	r24, 0xF7	; 247
 b0c:	91 e0       	ldi	r25, 0x01	; 1
 b0e:	90 93 5d 02 	sts	0x025D, r25
 b12:	80 93 5c 02 	sts	0x025C, r24

    /*  Set base address according to LoWaterMark. */
    LcdSend( 0x80 | ( LoWaterMark % LCD_X_RES ), LCD_CMD );
 b16:	20 91 5a 02 	lds	r18, 0x025A
 b1a:	30 91 5b 02 	lds	r19, 0x025B
 b1e:	c9 01       	movw	r24, r18
 b20:	64 e5       	ldi	r22, 0x54	; 84
 b22:	70 e0       	ldi	r23, 0x00	; 0
 b24:	7d d0       	rcall	.+250    	; 0xc20 <__divmodhi4>
 b26:	80 68       	ori	r24, 0x80	; 128
 * Return value :  None.
 */
static void LcdSend ( byte data, LcdCmdData cd )
{
    /*  Enable display controller (active low). */
    LCD_PORT &= ~( _BV( LCD_CE_PIN ) );
 b28:	c2 98       	cbi	0x18, 2	; 24
    {
        LCD_PORT |= _BV( LCD_DC_PIN );
    }
    else
    {
        LCD_PORT &= ~( _BV( LCD_DC_PIN ) );
 b2a:	c0 98       	cbi	0x18, 0	; 24
    }
	
    /*  Send data to display controller. */
    SPDR = data;
 b2c:	8f b9       	out	0x0f, r24	; 15

    /*  Wait until Tx register empty. */
    while ( (SPSR & 0x80) != 0x80 );
 b2e:	77 9b       	sbis	0x0e, 7	; 14
 b30:	fe cf       	rjmp	.-4      	; 0xb2e <LcdUpdate+0x68>
	

    /* Disable display controller. */
    LCD_PORT |= _BV( LCD_CE_PIN );
 b32:	c2 9a       	sbi	0x18, 2	; 24
    else if ( HiWaterMark >= LCD_CACHE_SIZE )
        HiWaterMark = LCD_CACHE_SIZE - 1;

    /*  Set base address according to LoWaterMark. */
    LcdSend( 0x80 | ( LoWaterMark % LCD_X_RES ), LCD_CMD );
    LcdSend( 0x40 | ( LoWaterMark / LCD_X_RES ), LCD_CMD );
 b34:	c9 01       	movw	r24, r18
 b36:	64 e5       	ldi	r22, 0x54	; 84
 b38:	70 e0       	ldi	r23, 0x00	; 0
 b3a:	72 d0       	rcall	.+228    	; 0xc20 <__divmodhi4>
 b3c:	60 64       	ori	r22, 0x40	; 64
 * Return value :  None.
 */
static void LcdSend ( byte data, LcdCmdData cd )
{
    /*  Enable display controller (active low). */
    LCD_PORT &= ~( _BV( LCD_CE_PIN ) );
 b3e:	c2 98       	cbi	0x18, 2	; 24
    {
        LCD_PORT |= _BV( LCD_DC_PIN );
    }
    else
    {
        LCD_PORT &= ~( _BV( LCD_DC_PIN ) );
 b40:	c0 98       	cbi	0x18, 0	; 24
    }
	
    /*  Send data to display controller. */
    SPDR = data;
 b42:	6f b9       	out	0x0f, r22	; 15

    /*  Wait until Tx register empty. */
    while ( (SPSR & 0x80) != 0x80 );
 b44:	77 9b       	sbis	0x0e, 7	; 14
 b46:	fe cf       	rjmp	.-4      	; 0xb44 <LcdUpdate+0x7e>
	

    /* Disable display controller. */
    LCD_PORT |= _BV( LCD_CE_PIN );
 b48:	c2 9a       	sbi	0x18, 2	; 24
    /*  Set base address according to LoWaterMark. */
    LcdSend( 0x80 | ( LoWaterMark % LCD_X_RES ), LCD_CMD );
    LcdSend( 0x40 | ( LoWaterMark / LCD_X_RES ), LCD_CMD );

    /*  Serialize the display buffer. */
    for ( i = LoWaterMark; i <= HiWaterMark; i++ )
 b4a:	40 91 5c 02 	lds	r20, 0x025C
 b4e:	50 91 5d 02 	lds	r21, 0x025D
 b52:	f9 01       	movw	r30, r18
 b54:	e0 5a       	subi	r30, 0xA0	; 160
 b56:	ff 4f       	sbci	r31, 0xFF	; 255
 b58:	0a c0       	rjmp	.+20     	; 0xb6e <LcdUpdate+0xa8>
    {
        LcdSend( LcdCache[ i ], LCD_DATA );
 b5a:	80 81       	ld	r24, Z
 * Return value :  None.
 */
static void LcdSend ( byte data, LcdCmdData cd )
{
    /*  Enable display controller (active low). */
    LCD_PORT &= ~( _BV( LCD_CE_PIN ) );
 b5c:	c2 98       	cbi	0x18, 2	; 24

    if ( cd == LCD_DATA )
    {
        LCD_PORT |= _BV( LCD_DC_PIN );
 b5e:	c0 9a       	sbi	0x18, 0	; 24
    {
        LCD_PORT &= ~( _BV( LCD_DC_PIN ) );
    }
	
    /*  Send data to display controller. */
    SPDR = data;
 b60:	8f b9       	out	0x0f, r24	; 15

    /*  Wait until Tx register empty. */
    while ( (SPSR & 0x80) != 0x80 );
 b62:	77 9b       	sbis	0x0e, 7	; 14
 b64:	fe cf       	rjmp	.-4      	; 0xb62 <LcdUpdate+0x9c>
	

    /* Disable display controller. */
    LCD_PORT |= _BV( LCD_CE_PIN );
 b66:	c2 9a       	sbi	0x18, 2	; 24
    /*  Set base address according to LoWaterMark. */
    LcdSend( 0x80 | ( LoWaterMark % LCD_X_RES ), LCD_CMD );
    LcdSend( 0x40 | ( LoWaterMark / LCD_X_RES ), LCD_CMD );

    /*  Serialize the display buffer. */
    for ( i = LoWaterMark; i <= HiWaterMark; i++ )
 b68:	2f 5f       	subi	r18, 0xFF	; 255
 b6a:	3f 4f       	sbci	r19, 0xFF	; 255
 b6c:	31 96       	adiw	r30, 0x01	; 1
 b6e:	42 17       	cp	r20, r18
 b70:	53 07       	cpc	r21, r19
 b72:	9c f7       	brge	.-26     	; 0xb5a <LcdUpdate+0x94>
    {
        LcdSend( LcdCache[ i ], LCD_DATA );
    }

    /*  Reset watermark pointers. */
    LoWaterMark = LCD_CACHE_SIZE - 1;
 b74:	87 ef       	ldi	r24, 0xF7	; 247
 b76:	91 e0       	ldi	r25, 0x01	; 1
 b78:	90 93 5b 02 	sts	0x025B, r25
 b7c:	80 93 5a 02 	sts	0x025A, r24
    HiWaterMark = 0;
 b80:	10 92 5d 02 	sts	0x025D, r1
 b84:	10 92 5c 02 	sts	0x025C, r1

    /* Set update flag to be true */
	UpdateLcd = FALSE;
 b88:	10 92 5e 02 	sts	0x025E, r1
}
 b8c:	08 95       	ret

00000b8e <LcdInit>:
 * Description  :  Performs MCU SPI & LCD controller initialization.
 * Argument(s)  :  None.
 * Return value :  None.
 */
void LcdInit ( void )
{
 b8e:	c4 9a       	sbi	0x18, 4	; 24
    /* Pull-up on reset pin. */
    LCD_PORT |= _BV ( LCD_RST_PIN );

    /* Set output bits on LCD Port. */
    LCD_DDR |= _BV( LCD_RST_PIN ) | _BV( LCD_DC_PIN ) | _BV( LCD_CE_PIN ) | _BV( SPI_MOSI_PIN ) | _BV( SPI_CLK_PIN );
 b90:	87 b3       	in	r24, 0x17	; 23
 b92:	8d 63       	ori	r24, 0x3D	; 61
 b94:	87 bb       	out	0x17, r24	; 23

    Delay();

    /* Toggle display reset pin. */
    LCD_PORT &= ~( _BV( LCD_RST_PIN ) );
 b96:	c4 98       	cbi	0x18, 4	; 24
    Delay();
    LCD_PORT |= _BV ( LCD_RST_PIN );
 b98:	c4 9a       	sbi	0x18, 4	; 24

    /* Enable SPI port: 
    * No interrupt, MSBit first, Master mode, CPOL->0, CPHA->0, Clk/4
    */
    SPCR = 0x50;
 b9a:	80 e5       	ldi	r24, 0x50	; 80
 b9c:	8d b9       	out	0x0d, r24	; 13

    /* Disable LCD controller */
    LCD_PORT |= _BV( LCD_CE_PIN );
 b9e:	c2 9a       	sbi	0x18, 2	; 24
 * Return value :  None.
 */
static void LcdSend ( byte data, LcdCmdData cd )
{
    /*  Enable display controller (active low). */
    LCD_PORT &= ~( _BV( LCD_CE_PIN ) );
 ba0:	c2 98       	cbi	0x18, 2	; 24
    {
        LCD_PORT |= _BV( LCD_DC_PIN );
    }
    else
    {
        LCD_PORT &= ~( _BV( LCD_DC_PIN ) );
 ba2:	c0 98       	cbi	0x18, 0	; 24
    }
	
    /*  Send data to display controller. */
    SPDR = data;
 ba4:	81 e2       	ldi	r24, 0x21	; 33
 ba6:	8f b9       	out	0x0f, r24	; 15

    /*  Wait until Tx register empty. */
    while ( (SPSR & 0x80) != 0x80 );
 ba8:	77 9b       	sbis	0x0e, 7	; 14
 baa:	fe cf       	rjmp	.-4      	; 0xba8 <LcdInit+0x1a>
	

    /* Disable display controller. */
    LCD_PORT |= _BV( LCD_CE_PIN );
 bac:	c2 9a       	sbi	0x18, 2	; 24
 * Return value :  None.
 */
static void LcdSend ( byte data, LcdCmdData cd )
{
    /*  Enable display controller (active low). */
    LCD_PORT &= ~( _BV( LCD_CE_PIN ) );
 bae:	c2 98       	cbi	0x18, 2	; 24
    {
        LCD_PORT |= _BV( LCD_DC_PIN );
    }
    else
    {
        LCD_PORT &= ~( _BV( LCD_DC_PIN ) );
 bb0:	c0 98       	cbi	0x18, 0	; 24
    }
	
    /*  Send data to display controller. */
    SPDR = data;
 bb2:	88 ec       	ldi	r24, 0xC8	; 200
 bb4:	8f b9       	out	0x0f, r24	; 15

    /*  Wait until Tx register empty. */
    while ( (SPSR & 0x80) != 0x80 );
 bb6:	77 9b       	sbis	0x0e, 7	; 14
 bb8:	fe cf       	rjmp	.-4      	; 0xbb6 <LcdInit+0x28>
	

    /* Disable display controller. */
    LCD_PORT |= _BV( LCD_CE_PIN );
 bba:	c2 9a       	sbi	0x18, 2	; 24
 * Return value :  None.
 */
static void LcdSend ( byte data, LcdCmdData cd )
{
    /*  Enable display controller (active low). */
    LCD_PORT &= ~( _BV( LCD_CE_PIN ) );
 bbc:	c2 98       	cbi	0x18, 2	; 24
    {
        LCD_PORT |= _BV( LCD_DC_PIN );
    }
    else
    {
        LCD_PORT &= ~( _BV( LCD_DC_PIN ) );
 bbe:	c0 98       	cbi	0x18, 0	; 24
    }
	
    /*  Send data to display controller. */
    SPDR = data;
 bc0:	86 e0       	ldi	r24, 0x06	; 6
 bc2:	8f b9       	out	0x0f, r24	; 15

    /*  Wait until Tx register empty. */
    while ( (SPSR & 0x80) != 0x80 );
 bc4:	77 9b       	sbis	0x0e, 7	; 14
 bc6:	fe cf       	rjmp	.-4      	; 0xbc4 <LcdInit+0x36>
	

    /* Disable display controller. */
    LCD_PORT |= _BV( LCD_CE_PIN );
 bc8:	c2 9a       	sbi	0x18, 2	; 24
 * Return value :  None.
 */
static void LcdSend ( byte data, LcdCmdData cd )
{
    /*  Enable display controller (active low). */
    LCD_PORT &= ~( _BV( LCD_CE_PIN ) );
 bca:	c2 98       	cbi	0x18, 2	; 24
    {
        LCD_PORT |= _BV( LCD_DC_PIN );
    }
    else
    {
        LCD_PORT &= ~( _BV( LCD_DC_PIN ) );
 bcc:	c0 98       	cbi	0x18, 0	; 24
    }
	
    /*  Send data to display controller. */
    SPDR = data;
 bce:	83 e