lcd.c

color_lcd_test

/*********************************************************************************************
* File：	lcd.c
* Author:	Embest	
* Desc：	lcd source code 
* History:	
*			Y.J.Guo, Programming modify, April 12, 2005
*********************************************************************************************/

/*------------------------------------------------------------------------------------------*/
/*	 								include files						 				    */
/*------------------------------------------------------------------------------------------*/
#include <string.h>
#include "2410lib.h"
#include "lcd.h"
#include "glib.h"
#include "lcdlib.h"
#include "demo256.h"

/*------------------------------------------------------------------------------------------*/
/*	 								functions declare                                       */
/*------------------------------------------------------------------------------------------*/
void Lcd_port_init(void);
void Lcd_Port_Return(void);
void Lcd_Palette1Bit_Init(void);
void Lcd_Palette8Bit_Init(void);
void Lcd_Int_Frame(void) __attribute__ ((interrupt ("IRQ")));
void Lcd_Int_Fifo(void) __attribute__ ((interrupt ("IRQ")));
void Lcd_Int_Fifo_640480(void) __attribute__ ((interrupt ("IRQ")));

/*------------------------------------------------------------------------------------------*/
/*	 								global variables						 			    */
/*------------------------------------------------------------------------------------------*/
unsigned save_rGPCUP,save_rGPCDAT,save_rGPCCON;
unsigned save_rGPDUP,save_rGPDDAT,save_rGPDCON; 
unsigned lcd_count;

/*********************************************************************************************
* name:		Lcd_port_init()
* func:		lcd port initialization
* para:		none
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void Lcd_port_init(void)
{
    save_rGPCCON=rGPCCON;
    save_rGPCDAT=rGPCDAT;
    save_rGPCUP=rGPCUP;
    save_rGPDCON=rGPDCON;
    save_rGPDDAT=rGPDDAT;
    save_rGPDUP=rGPDUP;
    rGPCUP=0xffffffff;                                          // Disable Pull-up register
    rGPCCON=0xaaaaa9aa;                                         // Initialize VD[7:0],LCDVF[2:0],VM,VFRAME,VLINE,VCLK,LEND 
    rGPDUP=0xffffffff;                                          // Disable Pull-up register
    rGPDCON=0xaaaaaaaa;                                         // Initialize VD[23:8]
    uart_printf(" Initializing GPIO ports..........\n");
}

/*********************************************************************************************
* name:		Lcd_Port_Return()
* func:		Return lcd port configuration
* para:		none
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void Lcd_Port_Return(void)
{
    rGPCCON=save_rGPCCON;
    rGPCDAT=save_rGPCDAT;
    rGPCUP=save_rGPCUP;
    rGPDCON=save_rGPDCON;
    rGPDDAT=save_rGPDDAT;
    rGPDUP=save_rGPDUP;
}

/*********************************************************************************************
* name:		Lcd_Palette1Bit_Init()
* func:		Lcd 1 bpp palette initialization
* para:		none
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void Lcd_Palette1Bit_Init(void)
{
    UINT32T *palette;
    palette=(UINT32T *)PALETTE;
    *palette++=0x0;                                             // Black
    *palette=0xffff;                                            // White
}

/*********************************************************************************************
* name:		Lcd_Palette8Bit_Init()
* func:		Lcd 8 bpp palette initialization
* para:		none
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void Lcd_Palette8Bit_Init(void)
{
    int i;	
    UINT32T *palette;
    rLCDCON5|=(1<<11);                                          // 5:6:5 Palette Setting
    palette=(UINT32T *)PALETTE;
    for(i=0;i<256;i++)
	*palette++=DEMO256pal[i];
}

/*********************************************************************************************
* name:		Lcd_Int_Frame()
* func:		Lcd frame interrupt
* para:		none
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void Lcd_Int_Frame(void)
{
    rLCDINTMSK|=3;                                              // Mask LCD SUB Interrupt

    // GPG4 is .... 
    rGPGDAT&=(~(1<<4));                                         // GPG4=Low
    delay(50);                                                  // GPG4=Low
    rGPGDAT|=(1<<4);                                            // GPG4=High

    rLCDSRCPND=2;                                               // Clear LCD SUB Interrupt source pending
    rLCDINTPND=2;                                               // Clear LCD SUB Interrupt pending
    rLCDINTMSK&=(~(2));                                         // Unmask LCD FRAME Interrupt
    ClearPending(BIT_LCD);
}

/*********************************************************************************************
* name:		Lcd_Int_Fifo()
* func:		Lcd Fifo interrupt
* para:		none
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void Lcd_Int_Fifo(void)
{
    rLCDINTMSK|=3;                                              // Mask LCD SUB Interrupt

    if((lcd_count%20)==0) uart_printf(" \n");
    uart_printf(" .");
    lcd_count++;

    rLCDSRCPND=1;                                               // Clear LCD SUB Interrupt source pending
    rLCDINTPND=1;                                               // Clear LCD SUB Interrupt pending
    rLCDINTMSK&=(~(1));                                         // Unmask LCD FRAME Interrupt
    ClearPending(BIT_LCD);
}

/*********************************************************************************************
* name:		Test_Lcd_Stn_1Bit()
* func:		test 1bpp stn LCD
* para:		none
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void Test_Lcd_Stn_1Bit(void)
{
    int i,j;
    Lcd_port_init();
    Lcd_Init(MODE_STN_1BIT);
    Glib_Init(MODE_STN_1BIT);
    Lcd_EnvidOnOff(1);                                          // Enable ENVID Bit
    uart_printf("  STN Mono(1bit/1pixel) LCD Test\n");              

    Glib_ClearScr(0, MODE_STN_1BIT);
    for(j=0;j<LCD_YSIZE_STN;j+=16)
		for(i=0;i<LCD_XSIZE_STN;i+=16)
		    Glib_FilledRectangle(i,j,i+15,j+15,((j+i)/16)%2);
    uart_printf(" STN Mono test 1. Press any key!\n");
    uart_getch();  	

    Glib_ClearScr(0, MODE_STN_1BIT);
    Glib_FilledRectangle(160,0,319,239,1);                      //Half Screen
    uart_printf(" STN Mono test 2. Press any key!\n");
    uart_getch();  	

    Glib_ClearScr(0, MODE_STN_1BIT); 
    Glib_Rectangle(0,0,319,239,1);                              // #0
    Glib_Line(0,0,319,239,1);                                   // 00
    Glib_Line(0,239,319,0,1);

    Glib_Rectangle(0+320,0,319+320,239,1);                      // 0#
    Glib_Line(0+320,0,319+320,239,1);                           // 00
    Glib_Line(0+320,239,319+320,0,1);
    Glib_FilledRectangle(50+320,50,269+320,189,1);

    Glib_Rectangle(0,0+240,319,239+240,1);                      // 00
    Glib_Line(0,0+240,319,239+240,1);                           // #0
    Glib_Line(0,239+240,319,0+240,1);
    Glib_FilledRectangle(50,50+240,269,189+240,1);
    
    Glib_Rectangle(0+320,0+240,319+320,239+240,1);              // 00	
    Glib_Line(0+320,0+240,319+320,239+240,1);                   // 0#
    Glib_Line(0+320,239+240,319+320,0+240,1);
    Glib_Rectangle(50+320,50+240,269+320,189+240,1);

    uart_printf(" Virtual Screen Test(STN Mono). Press any key[ijkm\\r]!\n");
    MoveViewPort(MODE_STN_1BIT);
    Lcd_MoveViewPort(0,0,MODE_STN_1BIT);
    Lcd_EnvidOnOff(0);                                          // Disable ENVID Bit
    Lcd_Port_Return();
}


/*********************************************************************************************
* name:		Test_Lcd_Stn_2Bit()
* func:		test 2bpp stn LCD
* para:		none
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void Test_Lcd_Stn_2Bit(void)
{
    int i,j,k;
    Lcd_port_init();
    Lcd_Init(MODE_STN_2BIT);
    Glib_Init(MODE_STN_2BIT);
    Lcd_EnvidOnOff(1);                                          // Enable ENVID Bit
    uart_printf("  STN 4 gray(2bit/1pixel) LCD Test\n");

    Glib_ClearScr(0, MODE_STN_2BIT);
    j=0;
    for(i=0;i<320;i+=80)
        Glib_FilledRectangle(0+i,0,79+i,239,j++);
    uart_printf(" 4 gray mode test 1. Press any key!\n");
    uart_getch();  	

    Glib_ClearScr(0, MODE_STN_2BIT);
    j=0;
    for(i=0;i<320;i+=80)
    {
    	Glib_FilledRectangle(0+i,0,79+i,119,j);
    	Glib_FilledRectangle(0+i,120,79+i,239,3-j);
    	j++;
   }
    uart_printf(" 4 gray mode test 2. Press any key!\n");
    uart_getch();  	

    Glib_ClearScr(0, MODE_STN_2BIT);
    j=0;
    for(i=0;i<240;i+=60)
    {
    	Glib_FilledRectangle(i,i,i+59,i+59,j);
    	j++;
   }
    uart_printf(" 4 gray mode test 3. Press any key!\n");
    uart_getch();  	

    Glib_ClearScr(0, MODE_STN_2BIT);
    k=0;
    for(i=160;i<480;i+=80)
    {
    	for(j=120;j<360;j+=60)
    	{
    	    Glib_FilledRectangle(i,j,i+79,j+59,k%4);
    	    k++;
    	}
    	k+=2;;
   }

    // #0
    // 00
    Glib_Rectangle(0,0,319,239,3);   
    Glib_Line(0,0,319,239,3);        
    Glib_Line(0,239,319,0,3);

    // 0#
    // 00
    Glib_Rectangle(0+320,0,319+320,239,3);          
    Glib_Line(0+320,0,319+320,239,3);        
    Glib_Line(0+320,239,319+320,0,3);

    // 00
    // #0
    Glib_Rectangle(0,0+240,319,239+240,3);          
    Glib_Line(0,0+240,319,239+240,3);        
    Glib_Line(0,239+240,319,0+240,3);

    // 00
    // 0#
    Glib_Line(0+320,0+240,319+320,239+240,3);        
    Glib_Line(0+320,239+240,319+320,0+240,3);
    Glib_Rectangle(50+320,50+240,269+320,189+240,3);

    uart_printf(" Virtual Screen Test(STN 4 gray). Press any key[ijkm\\r]!\n");
    MoveViewPort(MODE_STN_2BIT);
    Lcd_MoveViewPort(0,0,MODE_STN_2BIT);
    Lcd_EnvidOnOff(0);                                          // Disable ENVID Bit
    Lcd_Port_Return();
}


/*********************************************************************************************
* name:		Test_Lcd_Stn_4Bit()
* func:		test 4bpp stn LCD
* para:		none
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void Test_Lcd_Stn_4Bit(void)
{
    int i,j,k;
    Lcd_port_init();
    Lcd_Init(MODE_STN_4BIT);
    Glib_Init(MODE_STN_4BIT);
    Lcd_EnvidOnOff(1);
    uart_printf("  STN 16 gray(4bit/1pixel) LCD Test\n");

    Glib_ClearScr(0, MODE_STN_4BIT);
    j=0;
    for(i=0;i<320;i+=20)
        Glib_FilledRectangle(0+i,0,19+i,239,j++);
    uart_printf(" 16 gray mode test 1. Press any key!\n");
    uart_getch();  	

    Glib_ClearScr(0, MODE_STN_4BIT);
    j=0;
    for(i=0;i<320;i+=20)
    {
    	Glib_FilledRectangle(0+i,0,19+i,119,j);
    	Glib_FilledRectangle(0+i,120,19+i,239,15-j);
    	j++;
   }
    uart_printf(" 16 gray mode test 2. Press any key!\n");
    uart_getch();  	


    Glib_ClearScr(0, MODE_STN_4BIT);
    j=0;
    for(i=0;i<240;i+=30)
    {
    	Glib_FilledRectangle(i,i,i+29,i+29,j);
    	Glib_FilledRectangle(i+110,i,i+29+110,i+29,j+8);
    	j++;
   }
    uart_printf(" 4 gray mode test 3. Press any key!\n");
    uart_getch();  	 


    Glib_ClearScr(0, MODE_STN_4BIT);
    k=0;
    for(i=160;i<480;i+=40)
    	for(j=120;j<360;j+=30)
    	{
    	    Glib_FilledRectangle(i,j,i+39,j+29,k%16);
    	    k++;
    	}
    		    
    // #0		    
    // 00		    
    Glib_Rectangle(0,0,319,239,15);   
    Glib_Line(0,0,319,239,15);        
    Glib_Line(0,239,319,0,15);

    // 0#
    // 00
    Glib_Rectangle(0+320,0,319+320,239,15);
    Glib_Line(0+320,0,319+320,239,15);        
    Glib_Line(0+320,239,319+320,0,15);

    // 00
    // #0
    Glib_Rectangle(0,0+240,319,239+240,15);
    Glib_Line(0,0+240,319,239+240,15);        
    Glib_Line(0,239+240,319,0+240,15);