LCD demo程序(基于AB1601)

LCD:SX144QQ14P

#define SPI_LED PIO21 //
#define SPI_RS PIO1 //LED




#define ROW   160
#define COL   128


#define RED     0xF800
#define GREEN   0x07E0
#define BLUE   0x001F
#define WHITE   0xFFFF
#define BLACK   0x0000
#define BACKGROUND_COLOR 0x87E0

static volatile U8 SpiRxBuf[16];








void SpiGpioLedInit(void)
{
DRV_PinMux_SigSet( (1L << SPI_LED), PIN_GPIO);
DRV_Gpio_DirSet( (1L << SPI_LED), 1);
DRV_Gpio_PullSet( (1L << SPI_LED), PULL_UP);
DRV_Gpio_ValSet( (1L << SPI_LED), 1);
}




void SpiGpioLedHigh(void)
{
DRV_Gpio_ValSet((1L << SPI_LED), 1);
}




void SpiGpioLedLow(void)
{
DRV_Gpio_ValSet((1L << SPI_LED), 0);
}












void SpiGpioRsInit(void)
{
DRV_PinMux_SigSet( (1L << SPI_RS), PIN_GPIO);
DRV_Gpio_DirSet( (1L << SPI_RS), 1);
DRV_Gpio_PullSet( (1L << SPI_RS), PULL_UP);
DRV_Gpio_ValSet( (1L << SPI_RS), 1);
}




void SpiGpioRsHigh(void)
{
DRV_Gpio_ValSet((1L << SPI_RS), 1);
}




void SpiGpioRsLow(void)
{
DRV_Gpio_ValSet((1L << SPI_RS), 0);
}






/*
static void SpiGpioCsInit(void)
{
DRV_PinMux_SigSet( (1L << SPI_CS), PIN_GPIO);
DRV_Gpio_DirSet( (1L << SPI_CS), 1);
DRV_Gpio_PullSet( (1L << SPI_CS), PULL_UP);
DRV_Gpio_ValSet( (1L << SPI_CS), 1);
}




static void SpiGpioCsHigh(void)
{
DRV_Gpio_ValSet((1L << SPI_CS), 1);
}




static void SpiGpioCsLow(void)
{
DRV_Gpio_ValSet((1L << SPI_CS), 0);
}
*/












void DRV_SPI_No_Wait_WriteRead (volatile uint8_t* txbuf, volatile uint16_t txsize, volatile uint8_t* rxbuf, volatile uint16_t rxsize)
{
SPI.TXSRCADDR.reg = (uint32_t)(&txbuf[0]);
SPI.RXDSTADDR.reg = (uint32_t)(&rxbuf[0]);
SPI.TBC.reg = txsize;
SPI.RBC.reg = rxsize;
SPI.TXFIFOSZ.reg = txsize + 1;
SPI.RXFIFOSZ.reg = rxsize + 1;
SPI.TXWPTR.field.PTR = txsize;


SPI.RXRPTR.field.PTR = 0;


SPI.CONTROL.field.START = 1;


    while(! SPI.STATUS.field.READY);
}










void LcdSpiWriteOneByte(volatile U8 regData)
{
volatile U8 spi_tx_buf[256];
spi_tx_buf[0] = regData;


SPI.TXSRCADDR.reg = (uint32_t)(&spi_tx_buf[0]);
SPI.RXDSTADDR.reg = (uint32_t)(&SpiRxBuf[0]);
SPI.TBC.reg = 1;
SPI.RBC.reg = 0;
SPI.TXFIFOSZ.reg = 1 + 1;
SPI.RXFIFOSZ.reg = 0 + 1;
SPI.TXWPTR.field.PTR = 1;


SPI.RXRPTR.field.PTR = 0;


SPI.CONTROL.field.START = 1;


    while(! SPI.STATUS.field.READY);
}




















void spi_BusOpen(void)
{
    DRV_PinMux_GrpSet(SPI_PIN_MASK0, PIN_SPI);
}






void spi_BusClose(void)
{
    DRV_PinMux_SigSet(SPI_PIN_MASK0, PIN_GPIO);
}










void LcdSpiInit(void)
{
Ab_SpiParam init_parm;


DRV_PinMux_GrpSet(SPI_PIN_MASK0, PIN_SPI);


//init_parm.clk = 1000000;
init_parm.clk = 8000000;
//init_parm.clk = 24000000;




init_parm.mode = SPI_MODE0;//ok
//init_parm.mode = SPI_MODE1;//failure
//init_parm.mode = SPI_MODE2;//failure
//init_parm.mode = SPI_MODE3;//ok






init_parm.is_bidirection = false;
AB_SPI_Open(spi1_ins, &init_parm);
DRV_SPI_Int(0, false);
SPI.CONFIG.field.FDM = false;


LCD_PRINT("spi master is open on spi %d mode:%d\n", spi1_ins, init_parm.mode);
}
















/*
void DRV_SPI_No_Wait_WriteRead (uint8_t* txbuf, uint16_t txsize, uint8_t* rxbuf, uint16_t rxsize)
{
SPI.TXSRCADDR.reg = (uint32_t)txbuf;
SPI.RXDSTADDR.reg = (uint32_t)rxbuf;
SPI.TBC.reg = txsize;
SPI.RBC.reg = rxsize;
SPI.TXFIFOSZ.reg = txsize + 1;
SPI.RXFIFOSZ.reg = rxsize + 1;
SPI.TXWPTR.field.PTR = txsize;


SPI.RXRPTR.field.PTR = 0;


SPI.CONTROL.field.START = 1;


    while(! SPI.STATUS.field.READY);
}












void LcdSpiWriteOneByte(U8 regData)
{
U8 spi_tx_buf[256];
spi_tx_buf[0] = regData;


SPI.TXSRCADDR.reg = (uint32_t)spi_tx_buf;
SPI.RXDSTADDR.reg = (uint32_t)SpiRxBuf;
SPI.TBC.reg = 1;
SPI.RBC.reg = 0;
SPI.TXFIFOSZ.reg = 1 + 1;
SPI.RXFIFOSZ.reg = 0 + 1;
SPI.TXWPTR.field.PTR = 1;


SPI.RXRPTR.field.PTR = 0;


SPI.CONTROL.field.START = 1;


    while(! SPI.STATUS.field.READY);
}
*/








U8 LcdSpiReadOneByte(void)
{
U8 spi_tx_buf[256];
SPI.TXSRCADDR.reg = (uint32_t)spi_tx_buf;
SPI.RXDSTADDR.reg = (uint32_t)SpiRxBuf;
SPI.TBC.reg = 0;
SPI.RBC.reg = 1;
SPI.TXFIFOSZ.reg = 0 + 1;
SPI.RXFIFOSZ.reg = 1 + 1;
SPI.TXWPTR.field.PTR = 0;


SPI.RXRPTR.field.PTR = 0;


SPI.CONTROL.field.START = 1;


    while(! SPI.STATUS.field.READY);
return SpiRxBuf[0];
}
//*/








///*
void LcdSpiWriteMulByte(U8 *pData, U8 dataLen)
{
U16 i;
U8 spi_tx_buf[256];
for(i=0; i<dataLen; i++)
{
spi_tx_buf[i] = pData[i];
}
DRV_SPI_No_Wait_WriteRead(spi_tx_buf, dataLen, SpiRxBuf, 0);
}












U8 LcdSpiReadMulByte(U8 *spi_rx_buf, U8 dataLen)
{
U16 i;
U8 spi_tx_buf[256];
DRV_SPI_No_Wait_WriteRead(spi_tx_buf, 0, SpiRxBuf, dataLen);
for(i=0; i<dataLen; i++)
{
spi_rx_buf[i] = SpiRxBuf[i];
}
return dataLen;
}
//*/








void LcdWriteComm(unsigned char dat)
{
//SpiGpioCsLow();
SpiGpioRsLow();
LcdSpiWriteOneByte(dat);
//SpiGpioCsHigh();
}






void LcdWriteData(unsigned char dat)
{
//SpiGpioCsLow();
SpiGpioRsHigh();
LcdSpiWriteOneByte(dat);
//SpiGpioCsHigh();
}
//*/




void LcdBlockWrite(unsigned int Xstart,unsigned int Xend,unsigned int Ystart,unsigned int Yend)
{
LcdWriteComm(0x2A);
LcdWriteData(Xstart>>8);
LcdWriteData(Xstart);
LcdWriteData(Xend>>8);
LcdWriteData(Xend);


LcdWriteComm(0x2B);
LcdWriteData(Ystart>>8);
LcdWriteData(Ystart);
LcdWriteData(Yend>>8);
LcdWriteData(Yend);
LcdWriteComm(0x2c);
}








void LcdReset(void)
{
OS_delay_ms(100);
}






void LcdSpiGpioInit(void)
{
SpiGpioLedInit();
SpiGpioRsInit();
//SpiGpioCsInit();
}
//*/








void Lcd_Init(void)
{
//spi_BusOpen();
LcdSpiInit();


LcdSpiGpioInit();
LcdReset();


LcdWriteComm(0x11); //Sleep out
OS_delay_ms(120);   //Delay 120ms
//------------------------------------ST7735S Frame Rate-----------------------------------------//
LcdWriteComm(0xB1);
LcdWriteData(0x05);
LcdWriteData(0x3C);
LcdWriteData(0x3C);
LcdWriteComm(0xB2);
LcdWriteData(0x05);
LcdWriteData(0x3C);
LcdWriteData(0x3C);
LcdWriteComm(0xB3);
LcdWriteData(0x05);
LcdWriteData(0x3C);
LcdWriteData(0x3C);
LcdWriteData(0x05);
LcdWriteData(0x3C);
LcdWriteData(0x3C);
//------------------------------------End ST7735S Frame Rate-----------------------------------------//
LcdWriteComm(0xB4); //Dot inversion
LcdWriteData(0x03);


//------------------------------------ST7735S Power Sequence-----------------------------------------//
LcdWriteComm(0xC0);
LcdWriteData(0x28);
LcdWriteData(0x08);
LcdWriteData(0x04);
LcdWriteComm(0xC1);
LcdWriteData(0XC0);
LcdWriteComm(0xC2);
LcdWriteData(0x0D);
LcdWriteData(0x00);
LcdWriteComm(0xC3);
LcdWriteData(0x8D);
LcdWriteData(0x2A);
LcdWriteComm(0xC4);
LcdWriteData(0x8D);
LcdWriteData(0xEE);
//---------------------------------End ST7735S Power Sequence-------------------------------------//


LcdWriteComm(0xC5); //VCOM
LcdWriteData(0x1A);


LcdWriteComm(0x36); //MX, MY, RGB mode
LcdWriteData(0xc0);
//------------------------------------ST7735S Gamma Sequence-----------------------------------------//


LcdWriteComm(0xE0);
LcdWriteData(0x04);
LcdWriteData(0x22);
LcdWriteData(0x07);
LcdWriteData(0x0A);
LcdWriteData(0x2E);
LcdWriteData(0x30);
LcdWriteData(0x25);
LcdWriteData(0x2A);
LcdWriteData(0x28);
LcdWriteData(0x26);
LcdWriteData(0x2E);
LcdWriteData(0x3A);
LcdWriteData(0x00);


LcdWriteData(0x01);
LcdWriteData(0x03);
LcdWriteData(0x13);
LcdWriteComm(0xE1);
LcdWriteData(0x04);
LcdWriteData(0x16);
LcdWriteData(0x06);
LcdWriteData(0x0D);
LcdWriteData(0x2D);
LcdWriteData(0x26);
LcdWriteData(0x23);
LcdWriteData(0x27);
LcdWriteData(0x27);
LcdWriteData(0x25);
LcdWriteData(0x2D);
LcdWriteData(0x3B);
LcdWriteData(0x00);
LcdWriteData(0x01);
LcdWriteData(0x04);
LcdWriteData(0x13);
//------------------------------------End ST7735S Gamma Sequence-----------------------------------------//


LcdWriteComm(0x3A); //65k mode
LcdWriteData(0x05);
LcdWriteComm(0x29); //Display on
LcdWriteComm(0x2c);
}










#if 1
void LcdDispColor(unsigned int color)
{
unsigned int i,j;
unsigned char highByte;
unsigned char lowByte;
unsigned char offset;
unsigned char spi_tx_buf[256];
highByte = color>>8;
lowByte = color&0xff;
LcdBlockWrite(0, COL-1, 0, ROW-1);
SpiGpioRsHigh();
offset = 0x00;
for(i=0; i<ROW; i++)
{
   for(j=0; j<COL; j++)
{
    spi_tx_buf[offset++] = highByte;
    spi_tx_buf[offset++] = lowByte;
    if(offset == 128)
    {
    DRV_SPI_No_Wait_WriteRead(spi_tx_buf, offset, SpiRxBuf, 0);
offset = 0x00;
    }
}
}
printf("...AAA...\n");
}










void LcdTest(void)
{
u16 i=0;
U8 time[8];


Lcd_Init();
OS_delay_ms(200);


printf("...111...\n");
for(i=0; i<1; i++)
{
SpiGpioLedLow();
OS_delay_ms(200);
   SpiGpioLedHigh();
   OS_delay_ms(200);
}


printf("...222...\n");
LcdDispColor(BACKGROUND_COLOR);


time[0] = 0x17;
time[1] = 0x09;
time[2] = 0x27;
time[3] = 0x14;
time[4] = 0x30;
time[5] = 0x28;
time[6] = 0x03;
UpdateRtcSoftTime(time);




///*
while(1)
{
LcdDispColor(RED);
OS_delay_ms(1000);


LcdDispColor(GREEN);
OS_delay_ms(1000);


LcdDispColor(BLUE);
OS_delay_ms(1000);


LcdDispColor(WHITE);
OS_delay_ms(1000);


LcdDispColor(BLACK);
OS_delay_ms(1000);


printf("...333...\n");
}
//*/
 }
#endif










void LcdDispQrcode(unsigned char *qrcode)
{
unsigned int i,j;
unsigned char highByte;
unsigned char lowByte;
unsigned char offset;
unsigned char spi_tx_buf[256];
highByte = WHITE>>8;
lowByte = WHITE&0xff;
offset = 0x00;
LcdBlockWrite(15, 15+99-1, 15, 15+99-1);
SpiGpioRsHigh();
for(i=0; i<33; i++)
{
offset = 0x00;
   for(j=0; j<33; j++)
{
    if((qrcode[i*33+j]&0x01) == 0x00)
    {
    spi_tx_buf[offset++] = highByte;
    spi_tx_buf[offset++] = lowByte;
    spi_tx_buf[offset++] = highByte;
    spi_tx_buf[offset++] = lowByte;
    spi_tx_buf[offset++] = highByte;
    spi_tx_buf[offset++] = lowByte;
    }
    else
    {
    spi_tx_buf[offset++] = 0x00;
    spi_tx_buf[offset++] = 0x00;
    spi_tx_buf[offset++] = 0x00;
    spi_tx_buf[offset++] = 0x00;
    spi_tx_buf[offset++] = 0x00;
    spi_tx_buf[offset++] = 0x00;
    }
}
   DRV_SPI_No_Wait_WriteRead(spi_tx_buf, offset, SpiRxBuf, 0);
   DRV_SPI_No_Wait_WriteRead(spi_tx_buf, offset, SpiRxBuf, 0);
   DRV_SPI_No_Wait_WriteRead(spi_tx_buf, offset, SpiRxBuf, 0);
}
}








static void LcdDispOneFont(uint8_t font)
{
uint8_t i;
uint8_t j;
uint8_t tmp;
uint8_t offset;
uint8_t dotData[16];
uint8_t spi_tx_buf[256];
LcdGetFontDot(font, dotData);
for(i=0; i<16; i++)
{
tmp = dotData[i];
offset = 0x00;
for(j=0; j<8; j++)
{
if(tmp & 0x80)
{
spi_tx_buf[offset++] = 0x00;
spi_tx_buf[offset++] = 0x00;
}
else
{
spi_tx_buf[offset++] = BACKGROUND_COLOR>>8;
spi_tx_buf[offset++] = BACKGROUND_COLOR&0xff;
}
tmp = tmp<<1;
}
DRV_SPI_No_Wait_WriteRead(spi_tx_buf, offset, SpiRxBuf, 0);
}
}










void LcdDispRtcTime(uint8_t month, uint8_t day, uint8_t hour, uint8_t minute)
{
uint8_t i;
uint8_t dispData[16];
dispData[0] = month >> 4;
dispData[1] = month & 0x0F;
dispData[2] = '-';
dispData[3] = day >> 4;
dispData[4] = day & 0x0F;


dispData[5] = ' ';
dispData[6] = ' ';


dispData[7] = hour >> 4;
dispData[8] = hour & 0x0F;
dispData[9] = ':';
dispData[10] = minute >> 4;
dispData[11] = minute & 0x0F;
for(i=0; i<12; i++)
{
LcdBlockWrite(16+8*i, 16+8*i+8-1, 128, 128+16-1);//确定显示范围
SpiGpioRsHigh();
LcdDispOneFont(dispData[i]);
}
}








void LcdDispTimeDeal(void)
{
U8 flag;
U8 time[8];
flag = GetRtcLcdDispFlag();
if(flag == 1)
{


}
else
{
return;
}
ReadSoftRtcTime(time);
LcdDispRtcTime(time[1], time[2], time[3], time[4]);
}