#include "REG52.H"

sbit  LCDCS_dr  = P1^6;  //片选线
sbit  LCDSID_dr = P1^7;  //串行数据线
sbit  LCDCLK_dr = P3^2;  //串行时钟线
sbit  LCDRST_dr = P3^4;  //复位线

void SendByteToLcd(unsigned char ucData);  //发送一个字节数据到液晶模块
void SPIWrite(unsigned char ucWData, unsigned char ucWRS); //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
void WriteCommand(unsigned char ucCommand); //发送一个字节的命令给液晶模块
void LCDWriteData(unsigned char ucData);   //发送一个字节的数据给液晶模块
void LCDInit(void);  //初始化  函数内部包括液晶模块的复位
void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount); //显示任意点阵函数
void display_clear(void); // 清屏
void hz1616_mirror(const unsigned char  *p_ucHz,unsigned char *p_ucResult);  //把16x16点阵字库镜像
void hz816_mirror(const unsigned char  *p_ucHz,unsigned char *p_ucResult);  //把8x16点阵字库镜像

void delay_short(unsigned int uiDelayshort); //延时

code unsigned char Hz1616_man[]= /*馒   横向取模  16X16点阵 */
{
0x21,0xF8,0x21,0x08,0x21,0xF8,0x3D,0x08,0x45,0xF8,0x48,0x00,0x83,0xFC,0x22,0x94,
0x23,0xFC,0x20,0x00,0x21,0xF8,0x20,0x90,0x28,0x60,0x30,0x90,0x23,0x0E,0x00,0x00,
};

code unsigned char Hz1616_tou[]= /*头   横向取模  16X16点阵 */
{
0x00,0x80,0x10,0x80,0x0C,0x80,0x04,0x80,0x10,0x80,0x0C,0x80,0x08,0x80,0x00,0x80,
0xFF,0xFE,0x00,0x80,0x01,0x40,0x02,0x20,0x04,0x30,0x08,0x18,0x10,0x0C,0x20,0x08,
};


code unsigned char Zf816_V[]= /*V   横向取模  8x16点阵 */
{
0x00,0x00,0x00,0xE7,0x42,0x42,0x44,0x24,0x24,0x28,0x28,0x18,0x10,0x10,0x00,0x00,
};

code unsigned char Zf816_5[]= /*5   横向取模  8x16点阵 */
{
0x00,0x00,0x00,0x7E,0x40,0x40,0x40,0x58,0x64,0x02,0x02,0x42,0x44,0x38,0x00,0x00,
};


unsigned char ucBufferResult[32]; //用于临时存放转换结束后的字模数组

void main() 
  {
        LCDInit(); //初始化12864 内部包含液晶模块的复位

        display_clear(); // 清屏

        display_lattice(0,0,Hz1616_man,0,2,16);  //显示镜像前的<馒>字
        hz1616_mirror(Hz1616_man,ucBufferResult);  //把<馒>字镜像后放到ucBufferResult临时变量里。
        display_lattice(1,0,ucBufferResult,0,2,16);  //显示镜像后的<馒>字


        display_lattice(0,16,Hz1616_tou,0,2,16);  //显示镜像前的<头>字
        hz1616_mirror(Hz1616_tou,ucBufferResult);  //把<头>字镜像后放到ucBufferResult临时变量里。
        display_lattice(1,16,ucBufferResult,0,2,16);  //显示镜像后的<头>字

        display_lattice(8,0,Zf816_V,0,1,16);  //显示镜像前的<V>字符
        hz816_mirror(Zf816_V,ucBufferResult);  //把<V>字符镜像后放到ucBufferResult临时变量里。
        display_lattice(9,0,ucBufferResult,0,1,16);  //显示镜像后的<V>字符

        display_lattice(8,16,Zf816_5,0,1,16);  //显示镜像前的<5>字符
        hz816_mirror(Zf816_5,ucBufferResult);  //把<5>字符镜像后放到ucBufferResult临时变量里。
        display_lattice(9,16,ucBufferResult,0,1,16);  //显示镜像后的<5>字符

        while(1)  
        { 
             ;
        }

}



void display_clear(void) // 清屏
{    

    unsigned char x,y;
    WriteCommand(0x34);  //关显示缓冲指令            
    WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
    y=0;
    while(y<32)  //y轴的范围0至31
    {
         WriteCommand(y+0x80);        //垂直地址
         WriteCommand(0x80);          //水平地址
         for(x=0;x<32;x++)  //256个横向点，有32个字节
         {  
            LCDWriteData(0x00);
         }
         y++;
    }
    WriteCommand(0x36); //开显示缓冲指令

}

/* 注释一：
* 16x16点阵镜像的本质：
* 16x16点阵有16行，每行有2个字节，如果把这2个字节看成是一个16位int型数据，
* 那么就是要这个数据从原来左边是高位，右边是低位的顺序颠倒过来。本程序没有把2个字节
* 合并成一个int型数据，而是直接在一个字节数据内把高低位顺序颠倒过来，然后把第1字节数据跟第2字节数据交换。
*/
void hz1616_mirror(const unsigned char  *p_ucHz,unsigned char *p_ucResult)  //把16x16点阵字库镜像的函数
{
         unsigned char a;
         unsigned char b;
         unsigned char c;
         unsigned char d;
        
         for(a=0;a<16;a++) //这里16代表有16行。每一行有2个字节。把每一个字节看做一列，这里先把第1列字节的数据从原来左边是高位，右边是低位的顺序颠倒过来，相当于镜像。
         {
            b=p_ucHz[a*2+0];  //这里的2代表16x16点阵每行有2列字节，0代表从第1列开始。
            c=0;
            for(d=0;d<8;d++)  //把一个字节调换顺序
                {
               c=c>>1;
           if((b&0x80)==0x80)
                   {
             c=c|0x80;
           }
                   b=b<<1;
        }                 
        p_ucResult[a*2+1]=c;   //注意，因为是镜像，所以要把颠倒顺序后的字节从原来是第1列的调换到第2列         
     }
         
         for(a=0;a<16;a++)  //这里16代表有16行。每一行有2个字节。把每一个字节看做一列，这里先把第2列字节的数据从原来左边是高位，右边是低位的顺序颠倒过来，相当于镜像。
         {
            b=p_ucHz[a*2+1];   //这里的2代表16x16点阵每行有2列字节，1代表从第2列开始。
                 
            c=0;
            for(d=0;d<8;d++)  //把一个字节调换顺序
                {
                        c=c>>1;
            if((b&0x80)==0x80)
                        {
              c=c|0x80;
            }
                        b=b<<1;
         }

         p_ucResult[a*2+0]=c;         //注意，因为是镜像，所以要把颠倒顺序后的字节从原来是第2列的调换到第1列         

                 
     }
         

}



/* 注释二：
* 8x16点阵镜像的本质：
* 8x16点阵有16行，每行有1个字节，把这个数据从原来左边是高位，右边是低位的顺序颠倒过来。
*/
void hz816_mirror(const unsigned char  *p_ucHz,unsigned char *p_ucResult)  //把8x16点阵字库镜像的函数
{
         unsigned char a;
         unsigned char b;
         unsigned char c;
         unsigned char d;
        
         for(a=0;a<16;a++) //这里16代表有16行。每一行有1个字节。这里先把每一行字节的数据从原来左边是高位，右边是低位的顺序颠倒过来，相当于镜像。
         {
            b=p_ucHz[a*1+0];  //这里的1代表8x16点阵每行有1列字节，0代表从第1列开始。
            c=0;
            for(d=0;d<8;d++)  //把一个字节调换顺序
                {
               c=c>>1;
           if((b&0x80)==0x80)
                   {
             c=c|0x80;
           }
                   b=b<<1;
        }                 
        p_ucResult[a*1+0]=c;   //注意，因为每一行只有一列，所以不用像16x16点阵那样把第1列跟第2列对调交换。
     }
         
}



/* 注释三：本节的核心函数，读者尤其要搞懂x_amount和y_amount对应的显示关系。
* 第1，2个参数x,y是坐标体系。x的范围是0至15，y的范围是0至31.
* 第3个参数*ucArray是字模的数组。
* 第4个参数ucFbFlag是反白显示标志。0代表正常显示，1代表反白显示。
* 第5，6个参数x_amount，y_amount分别代表字模数组的横向有多少个字节，纵向有几横。
*/
void display_lattice(unsigned int x,unsigned int y,const unsigned char  *ucArray,unsigned char ucFbFlag,unsigned int x_amount,unsigned int y_amount)
{
   unsigned int j=0;
   unsigned int i=0;
   unsigned char ucTemp;
   WriteCommand(0x34);  //关显示缓冲指令            
   WriteCommand(0x34);  //关显示缓冲指令  故意写2次，怕1次关不了 这个是因为我参考到某厂家的驱动程序也是这样写的
   for(j=0;j<y_amount;j++) //y_amount代表y轴有多少横
   {
       WriteCommand(y+j+0x80);        //垂直地址
       WriteCommand(x+0x80);          //水平地址
       for(i=0;i<x_amount;i++) //x_amount代表x轴有多少列
       {
         ucTemp=ucArray[j*x_amount+i];
             if(ucFbFlag==1)  //反白显示
                 {
            ucTemp=~ucTemp;
         }
             LCDWriteData(ucTemp);
          //         delay_short(30000);  //把上一节这个延时函数去掉，加快刷屏速度
      }
   }
   WriteCommand(0x36); //开显示缓冲指令
}


void SendByteToLcd(unsigned char ucData)  //发送一个字节数据到液晶模块
{
        unsigned char i;
        for ( i = 0; i < 8; i++ )
        {
                if ( (ucData << i) & 0x80 )
                {
                        LCDSID_dr = 1;
                }
                else
                {
                        LCDSID_dr = 0;
                }
                LCDCLK_dr = 0;
                LCDCLK_dr = 1;
        }
}

void SPIWrite(unsigned char ucWData, unsigned char ucWRS) //模拟SPI发送一个字节的命令或者数据给液晶模块的底层驱动
{
        SendByteToLcd( 0xf8 + (ucWRS << 1) );
        SendByteToLcd( ucWData & 0xf0 );
        SendByteToLcd( (ucWData << 4) & 0xf0);
}


void WriteCommand(unsigned char ucCommand) //发送一个字节的命令给液晶模块
{

        LCDCS_dr = 0;
        LCDCS_dr = 1;
        SPIWrite(ucCommand, 0);
        delay_short(90); 
}

void LCDWriteData(unsigned char ucData)  //发送一个字节的数据给液晶模块
{
        LCDCS_dr = 0;
        LCDCS_dr = 1;
        SPIWrite(ucData, 1);
}

void LCDInit(void) //初始化  函数内部包括液晶模块的复位
{
        LCDRST_dr = 1;  //复位
        LCDRST_dr = 0;
        LCDRST_dr = 1;
}



void delay_short(unsigned int uiDelayShort) //延时函数
{
   unsigned int i;  
   for(i=0;i<uiDelayShort;i++)
   {
     ;  
   }
}