标题: 用STM32设计19264的屏程序 包括点、线、圆、矩形、反显、任意位置的读写、汉字字符... [打印本页]
作者: ll_cc    时间: 2016-6-21 15:50
标题: 用STM32设计19264的屏程序 包括点、线、圆、矩形、反显、任意位置的读写、汉字字符...
包括点、线、圆、矩形、反显、任意位置的读写、汉字字符的写，内容丰富，很有用 ，在产品中已经应用

  1. #include "stm32f10x.h"
  2. #include "lcd.h"
  3. #include "delay.h"
  4. #include "wdg.h"

  6. //////////////////////////////////////////////////////////////////////////////////         
  7. //        STM32F103RB控制LCD19264
  8. //  LCD数据接口   DB0-DB7    PA0--PA7  写：推挽输出，读：上拉输入
  9. //        LCD_CS1    PC9        CS1 CS2：00:左1/3屏，01:中1/3，10:右1/3    推挽输出
  10. /// LCD_CS2    PB11     推挽输出
  11. //  LCD_E      PB0      推挽输出
  12. //  LCD_RW     PB1      推挽输出
  13. //  LCD_RS     PB10     推挽输出
  14. //////////////////////////////////////////////////////////////////////////////////           
  15.    

  17. GPIO_InitTypeDef  GPIO_InitStructure;

  19. /*****************************************************************
  20.             字库函数
  21. *******************************************************************/
  22. void SPI_init(void)     //      SPI初始化
  23. {
  24.         SPI_InitTypeDef SPI_InitStructure;
  25.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB|RCC_APB2Periph_AFIO,ENABLE);
  26.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
  27.        
  28.         //初始化CS
  29.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
  30.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
  31.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  32.         GPIO_Init(GPIOB, &GPIO_InitStructure);

  34.         //初始化SCK   推挽复用输出
  35.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;
  36.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
  37.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  38.         GPIO_Init(GPIOB, &GPIO_InitStructure);
  39.         //初始化MISO 输入   上拉输入
  40.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14;

  42.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
  43.         GPIO_Init(GPIOB, &GPIO_InitStructure);
  44.         //初始化MOSI 输出   推挽复用输出
  45.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;
  46.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
  47.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  48.         GPIO_Init(GPIOB, &GPIO_InitStructure);       
  49.        
  50.         //SPI初始化
  51.         SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;     //  双线全双工
  52.         SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                          //  主模式
  53.         SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                      //  8位数据帧
  54.         SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;                            //
  55.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;                           //
  56.         SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                             //
  57.         SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8;   //  波特率预分频值
  58.         SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;                     // 数据传输从高位开始
  59.         SPI_InitStructure.SPI_CRCPolynomial = 7;                              //
  60.         SPI_Init(SPI2, &SPI_InitStructure);
  61.        
  62.         GPIO_SetBits(GPIOB,GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_15);
  63.         SPI_Cmd(SPI2, ENABLE);

  65. }
  66. //SPI 读写一个字节
  67. //TxData: 要写入的字节
  68. //返回值：要读取的字节
  69. u8 SPI_Send_byte(u8 dataa)
  70. {
  71.         u8 retry=0;
  72.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) != SET)
  73.         {
  74.                 retry++;
  75.                 if(retry>200)return 0;
  76.         }
  77.         SPI_I2S_SendData(SPI2, dataa);
  78.         retry=0;
  79.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) != SET)
  80.         {
  81.                 retry++;
  82.                 if(retry>200)return 0;
  83.         }
  84.         return SPI_I2S_ReceiveData(SPI2);
  85. }

  87. u8 SPI_Receive_byte(void)
  88. {
  89.         u8 retry=0;
  90.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) != SET)       
  91.         {
  92.                 retry++;
  93.                 if(retry>200)return 0;
  94.         }
  95.         SPI_I2S_SendData(SPI2, 0x00);
  96.        
  97.         retry=0;
  98.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET)
  99.         {
  100.                 retry++;
  101.                 if(retry>200)return 0;
  102.         }
  103.         return SPI_I2S_ReceiveData(SPI2);        
  104. }


  107. ////////////////////////////////////////////////////
  108. //  从字库芯片中读取len字节长度的数据   地址为24位
  109. //////////////////////////////////////////////////////
  110. void read_bytes_fromZIC(u8 *pbuffer,u32 addr,u16 len)
  111. {
  112.         u8 highaddr,middaddr,lowaddr;
  113.         u8 i;
  114.         u8 res;
  115.         highaddr=(u8)((addr)>>16)&0xff;
  116.         middaddr=(u8)((addr)>>8)&0xff;
  117.         lowaddr=(u8)(addr)&0xff;
  118. #        if read_fast_ic==0
  119.         ZIC_CS=0;
  120. //        ZIC_SCK=0;
  121.         SPI_Send_byte(0x03);
  122.         SPI_Send_byte(highaddr);
  123.         SPI_Send_byte(middaddr);
  124.         SPI_Send_byte(lowaddr);
  125.         for(i=0;i<len;i++)
  126.         {
  127.                 res = (u8)SPI_Receive_byte();
  128.                 pbuffer[i] = res;
  129.         }
  130.         ZIC_CS=1;
  131. # else
  132.         ZIC_CS=0;
  133. //        ZIC_SCK=0;
  134.         SPI_Send_byte(0x0B);
  135.         SPI_Send_byte(highaddr);
  136.         SPI_Send_byte(middaddr);
  137.         SPI_Send_byte(lowaddr);
  138.         SPI_Send_byte(0XFF);
  139.         for(i=0;i<len;i++)
  140.         {
  141.                 res = (u8)SPI_Receive_byte();
  142.                 *pbuffer = res;
  143.                 pbuffer+=1;
  144.         }
  145.         ZIC_CS=1;
  146. #endif
  147. }


  150. /**************************************************
  151.                  LCD函数
  152. ****************************************************/
  153. void LCD_Init(void)         //LED IO初始化
  154. {       
  155. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC, ENABLE);         //使能PA端口时钟
  156.         ////////////////////////////////////////////////////////////////////
  157.         ///数据口初始化为推挽输出
  158. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|
  159.                                       GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7;                                 //LED0-->PA. 端口配置
  160. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  //推挽输出
  161. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  162. GPIO_Init(GPIOA, &GPIO_InitStructure);
  163.                                        
  164. //////////////////////////////////////////////////////////////////////
  165.        
  166. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;                             //LCD-->PC.10  背光控制
  167. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  //推挽输出
  168. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  169. GPIO_Init(GPIOC, &GPIO_InitStructure);
  170.        
  171. GPIO_SetBits(GPIOC,GPIO_Pin_10);                                                  //PD.2 输出高
  172.         /////////////////////////////////////////////////

  174.        
  175. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9;                             //LCD控制口
  176. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  //推挽输出
  177. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  178. GPIO_Init(GPIOB, &GPIO_InitStructure);       

  180. GPIO_SetBits(GPIOB,GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9);                                                  //输出高

  182. }
  183. void LCD_confing(void)
  184. {
  185.         LCD_Init();
  186.         LCD_clear();
  187.         LCD_CS1=0;
  188.         LCD_CS2=0;
  189.         LCD_write_command(BEGIN_ROW) ;
  190.         LCD_write_command(LCD_ON);
  191.         LCD_CS1=0;
  192.         LCD_CS2=1;
  193.         LCD_write_command(BEGIN_ROW) ;
  194.         LCD_write_command(LCD_ON);
  195.         LCD_CS1=1;
  196.         LCD_CS2=0;
  197.         LCD_write_command(BEGIN_ROW) ;
  198.         LCD_write_command(LCD_ON);
  199.         SPI_init();
  200. }
  201. //////////////////////////////////////////////////
  202. //     函数名  Light_control()
  203. //     功能   背光控制  0 关背光  1 开背光
  204. /////////////////////////////////////////////////
  205. void Light_control(u8 light_flag)
  206. {
  207.         PCout(10) = light_flag;
  208. }
  209. //////////////////////////////////////////////////
  210. //查询状态位
  211. void checkbusy(void)
  212. {
  213.         u8 kk;
  214. /*        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|
  215.                                       GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7 ;
  216.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;    //浮空输入
  217.         GPIO_Init(GPIOA, &GPIO_InitStructure);        */
  218. /*        GPIO_SetBits(GPIOA, GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|
  219.                                       GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7);*/
  220.         GPIOA->CRL = 0x44444444;
  221.         GPIOA->BSRR=0X00FF;
  222.         while(1)
  223.         {
  224.                 LCD_RW=1;
  225.                 LCD_RS=0;
  226.                 LCD_E=1;
  227.                 delay_us(7);
  228.                 kk = (GPIOA->IDR&0xff)&0x80;
  229.                 delay_us(3);
  230.                 LCD_E=0;
  231.                 if(kk!=0x80)break;
  232.         }

  234. //        while(kk==0x80) ;
  235.         GPIOA->CRL = 0x33333333;
  236.        
  237. /*        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|
  238.                                       GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7;;
  239.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;    //推挽输出
  240.         GPIO_Init(GPIOA, &GPIO_InitStructure);*/
  241.        
  242. }
  243. /////////////////////////////////////////写命令
  244. void LCD_write_command(u8 command)
  245. {
  246.         checkbusy();
  247.         LCD_RW=0;
  248.         LCD_RS=0;
  249.         delay_us(1);
  250. //        GPIOA->ODR = GPIOA->ODR&0xff00;
  251.         GPIOA->ODR =  command;
  252.        
  253.         LCD_E=1;
  254.         delay_us(3);
  255.         LCD_E=0;

  257. }
  258. ////////////////////////////////////////写数据
  259. void LCD_write_data(u8 datt)
  260. {
  261.         checkbusy();
  262.         LCD_RW=0;
  263.         LCD_RS=1;
  264.         delay_us(1);
  265. //        GPIOA->ODR = GPIOA->ODR&0xff00 ;
  266.         GPIOA->ODR = datt;

  268.         LCD_E=1;
  269.         delay_us(3);
  270.         LCD_E=0;
  271. }
  272. //////////////////////////////////////读数据
  273. u8 LCD_read_data(void)
  274. {
  275.         u8 aa;
  276. /*        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|
  277.                                       GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7;                                 //LED0-->PA.8 端口配置
  278.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;                  //上拉输入
  279.   GPIO_Init(GPIOA, &GPIO_InitStructure);*/
  280.         delay_us(6);
  281.         GPIOA->CRL = 0x88888888;                       //初始化为上拉输入 PA0-7
  282.         GPIOA->BSRR=0X00FF;                             //假读一次
  283.         LCD_RW=1;
  284.         LCD_RS=1;
  285.         LCD_E=1;
  286.         LCD_E=0;
  287.        
  288.         GPIOA->BSRR=0X00FF;
  289.         LCD_RW=1;
  290.         LCD_RS=1;
  291.         LCD_E=1;
  292.         delay_us(3);                        //
  293.         aa=(u8)(GPIOA->IDR&0xff);
  294.         delay_us(2);
  295.         LCD_E=0;
  296.        
  297. /*        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|
  298.                                       GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7;                                 //LED0-->PA.8 端口配置
  299.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  //推挽输出
  300.   GPIO_Init(GPIOA, &GPIO_InitStructure);*/
  301.         GPIOA->CRL = 0x33333333;        //////推挽输出
  302.         GPIOA->BSRR=0X00FF;
  303.         return aa;
  304. }
  305. ///////////////////////////////////////////////连续读
  306. //                                   函数名：LCD_read_n_dat()
  307. //                                        功能  ：在指定的位置读取n列数据
  308. //
  309. //
  310. ///////////////////////////////////////////////
  311. void LCD_read_n_dat(u8 *buffer,u8 page,u8 y,u8 n)
  312. {
  313.         u8 i;
  314.        
  315.         LCD_write_command(BEGIN_PAGE+page);
  316.         LCD_write_command(BEGIN_Y+y);
  317.         delay_us(6);
  318.         GPIOA->CRL = 0x88888888;                             //初始化为上拉输入 PA0-7

  320.         GPIOA->BSRR=0X00FF;
  321.         LCD_RW=1;
  322.         LCD_RS=1;
  323.         LCD_E=1;
  324. //        delay_us(1);
  325.         LCD_E=0;
  326.        
  327.         GPIOA->BSRR=0X00FF;
  328.         LCD_RW=1;
  329.         LCD_RS=1;

  331.         for(i=0;i<n;i++)
  332.         {
  333.                 LCD_E=1;
  334.                 delay_us(3);
  335.                 buffer[i] =~((u8)(GPIOA->IDR&0x00ff));
  336. //                buffer[i] = ~buffer[i];
  337.                 delay_us(2);
  338.                 LCD_E=0;
  339.                 delay_us(3);
  340.         }
  341.         GPIOA->CRL = 0x33333333;        //////推挽输出
  342.         GPIOA->BSRR=0X00FF;

  344. }

  346. void LCD_read_zheng_dat(u8 *buffer,u8 page,u8 y,u8 n)
  347. {
  348.         u8 i;

  350.         LCD_write_command(BEGIN_PAGE+page);
  351.         LCD_write_command(BEGIN_Y+y);
  352.         delay_us(6);
  353.         GPIOA->CRL = 0x88888888;                             //初始化为上拉输入 PA0-7

  355.         GPIOA->BSRR=0X00FF;
  356.         LCD_RW=1;
  357.         LCD_RS=1;
  358.         LCD_E=1;
  359.         LCD_E=0;
  360.        
  361.         GPIOA->BSRR=0X00FF;
  362.         LCD_RW=1;
  363.         LCD_RS=1;

  365.         for(i=0;i<n;i++)
  366.         {
  367.                 LCD_E=1;
  368.                 delay_us(3);
  369.                 buffer[i] =(u8)(GPIOA->IDR&0x00ff);
  370.                 delay_us(2);
  371.                 LCD_E=0;
  372.                 delay_us(3);
  373.         }
  374.         GPIOA->CRL = 0x33333333;        //////推挽输出
  375.         GPIOA->BSRR=0X00FF;
  376. }
  377. ///////////////////////////////////////////////////////////
  378. //    函数名 ：display_onepage_reverse_cor
  379. //    功能   ：在指定的页反色显示
  380. //
  381. //
  382. ///////////////////////////////////////////////////////////
  383. void display_onepage_reverse_cor(u8 onepage,u8 y1,u8 len)
  384. {
  385.         u8 y2;
  386.         u8 andy;
  387.         u8 oddy;
  388.         u8 strdata[190];
  389.         y2 =y1+len-1;
  390.         if((y1<64)&&(y2<64))
  391.                 {
  392.                         LCD_CS1 =0;
  393.                         LCD_CS2 =0;
  394.                         LCD_read_n_dat(strdata,onepage,y1,len);
  395.                         write_page_8bit(strdata,onepage,y1, len);

  397.                 }
  398.                 else if((y1<64)&&(y2>=64)&&(y2<128))
  399.                 {
  400.                         oddy =64-y1;
  401.                         andy =len-oddy;
  402.                         LCD_CS1 =0;
  403.                         LCD_CS2 =0;
  404.                         LCD_read_n_dat(strdata,onepage,y1,oddy);
  405.                         write_page_8bit(strdata,onepage,y1, oddy);
  406.        
  407.                        
  408.                         LCD_CS1 =0;
  409.                         LCD_CS2 =1;
  410.                         LCD_read_n_dat(strdata,onepage,0,andy);
  411.                         write_page_8bit(strdata,onepage,0, andy);
  412.                        
  413.                 }
  414.                 else if((y1<64)&&(y2>=128))      //1、2、3屏中
  415.                 {
  416.                         oddy =64-y1;
  417.                         andy =y2-127;
  418.                 //        andy = len-64-oddy;
  419.                         LCD_CS1 =0;
  420.                         LCD_CS2 =0;
  421.                         LCD_read_n_dat(strdata,onepage,y1,oddy);
  422.                         write_page_8bit(strdata,onepage,y1, oddy);
  423.                        
  424.                         LCD_CS1 =0;
  425.                         LCD_CS2 =1;
  426.                         LCD_read_n_dat(strdata,onepage,0,64);
  427.                         write_page_8bit(strdata,onepage,0, 64);
  428.                        
  429.                         LCD_CS1 =1;
  430.                         LCD_CS2 =0;
  431.                         LCD_read_n_dat(strdata,onepage,0,andy);
  432.                         write_page_8bit(strdata,onepage,0, andy);
  433.                        
  434.                 }
  435.                 else if((y1>63)&&(y1<128)&&(y2<128))
  436.                 {
  437.                         LCD_CS1 =0;
  438.                         LCD_CS2 =1;
  439.                         LCD_read_n_dat(strdata,onepage,y1-64,len);
  440.                         write_page_8bit(strdata,onepage,y1-64, len);
  441.                 }
  442.                 else if((y1>63)&&(y1<128)&&(y2>=128))
  443.                 {
  444.                         oddy =128-y1;
  445.                         andy =len-oddy;
  446.                         LCD_CS1 =0;
  447.                         LCD_CS2 =1;
  448.                         LCD_read_n_dat(strdata,onepage,y1-64,oddy);
  449.                         write_page_8bit(strdata,onepage,y1-64, oddy);
  450.                        
  451.                         LCD_CS1 =1;
  452.                         LCD_CS2 =0;
  453.                        
  454.                         LCD_read_n_dat(strdata,onepage,0,andy);
  455.                         write_page_8bit(strdata,onepage,0, andy);
  456.                        
  457.                 }
  458.                 else
  459.                 {
  460.                         LCD_CS1 =1;
  461.                         LCD_CS2 =0;
  462.                         LCD_read_n_dat(strdata,onepage,y1-128,len);
  463.                         write_page_8bit(strdata,onepage,y1-128, len);               
  464.                 }
  465. }
  466. ///////////////////////////////////////////////////
  467. //      函数名 ：Set_byte_reverse()
  468. //      功能   ：单字节取反
  469. /////////////////////////////////////////////////
  470. u8 Set_low_byte_reverse(u8 datt,u8 len)    //从低位开始取反
  471. {
  472.         static u8 aa;
  473.         u8 i;
  474.         aa =datt;
  475.         for(i=0;i<len;i++)
  476.         {
  477.                 if(datt&0x01)aa &= (u8)(~(1<<i));       //取反
  478.                 else aa |= (u8)(1<<i);
  479.                 datt=datt>>1;
  480.         }
  481.         return aa;
  482. }

  484. u8 Set_high_byte_reverse(u8 datt,u8 len)     //从高位开始取反
  485. {
  486.         static u8 aa;
  487.         u8 i;
  488.         aa =datt;
  489.         for(i=0;i<len;i++)
  490.         {
  491.                 if(datt&0x80)aa &= (u8)(~(1<<(7-i)));
  492.                 else aa |= (u8)(1<<(7-i));
  493.                 datt=datt<<1;
  494.         }
  495.         return aa;
  496. }
  497. ////////////////////////////////////////////////////////////////////
  498. //        函数名：display_lossonepage_revcor
  499. //        功能  ：不足一页的反显
  500. //        corflag表示一页中向上取还是向下取值 0：上  1：下
  501. ////////////////////////////////////////////////////////////////////
  502. void display_lossonepage_revcor(u8 onepage,u8 onerow,u8 y1,u8 ylen,u8 corflag)
  503. {
  504.         u8 i;
  505.         u8 y2;
  506.         u8 oddy,andy;
  507.         u8 strdata[70];
  508.         u8 strdata1[70];
  509.         u8 strdata2[70];
  510.         y2 =y1+ylen-1;
  511.         if((y1<64)&&(y2<64))                ///////第一屏
  512.                 {
  513.                         LCD_CS1 =0;
  514.                         LCD_CS2 =0;
  515.                         IWDG_Feed();
  516.                         LCD_read_zheng_dat(strdata,onepage, y1,ylen);
  517.                         if(corflag==0)
  518.                         {
  519.                                 for(i=0;i<ylen;i++)
  520.                                 {
  521.                                         strdata[i] =Set_high_byte_reverse(strdata[i], onerow);
  522.                                 }
  523.                         }
  524.                         else
  525.                         {
  526.                                 for(i=0;i<ylen;i++)
  527.                                 {
  528.                                         strdata[i] =Set_low_byte_reverse(strdata[i], onerow);
  529.                                 }
  530.                         }
  531.                         IWDG_Feed();
  532.                         write_page_8bit(strdata,onepage,y1, ylen);
  533.                 }
  534.                 else if((y1<64)&&(y2>=64)&&(y2<128))        /////第一 屏和第二屏
  535.                 {
  536.                         oddy =64-y1;             //di yi ping
  537.                         andy =ylen-oddy;
  538.                         LCD_CS1 =0;
  539.                         LCD_CS2 =0;
  540.                         IWDG_Feed();
  541.                         LCD_read_zheng_dat(strdata,onepage, y1,oddy);
  542.                         if(corflag==0)
  543.                         {
  544.                                 for(i=0;i<oddy;i++)
  545.                                 {
  546.                                         strdata[i] =Set_high_byte_reverse(strdata[i], onerow);
  547.                                 }
  548.                         }
  549.                         else
  550.                         {
  551.                                 for(i=0;i<oddy;i++)
  552.                                 {
  553.                                         strdata[i] =Set_low_byte_reverse(strdata[i], onerow);
  554.                                 }
  555.                         }
  556.                         write_page_8bit(strdata,onepage,y1, oddy);

  558.                         LCD_CS1 =0;
  559.                         LCD_CS2 =1;
  560.                         LCD_read_zheng_dat(strdata1,onepage, 0,andy);
  561.                         if(corflag==0)
  562.                         {
  563.                                 for(i=0;i<andy;i++)
  564.                                 {
  565.                                         strdata1[i] =Set_high_byte_reverse(strdata1[i], onerow);
  566.                                 }
  567.                         }
  568.                         else
  569.                         {
  570.                                 for(i=0;i<andy;i++)
  571.                                 {
  572.                                         strdata1[i] =Set_low_byte_reverse(strdata1[i], onerow);
  573.                                 }
  574.                         }
  575.                         IWDG_Feed();
  576.                         write_page_8bit(strdata1,onepage,0, andy);
  577.                 }
  578.                 else if((y1<64)&&(y2>=128))           /////////////第123屏
  579.                 {
  580.                         oddy =64-y1;
  581.                         andy =y2-127;
  582.                         LCD_CS1 =0;
  583.                         LCD_CS2 =0;
  584.                         IWDG_Feed();
  585.                         LCD_read_zheng_dat(strdata,onepage, y1,oddy);
  586.                         if(corflag==0)
  587.                         {
  588.                                 for(i=0;i<oddy;i++)
  589.                                 {
  590.                                         strdata[i] =Set_high_byte_reverse(strdata[i], onerow);
  591.                                 }
  592.                         }
  593.                         else
  594.                         {
  595.                                 for(i=0;i<oddy;i++)
  596.                                 {
  597.                                         strdata[i] =Set_low_byte_reverse(strdata[i], onerow);
  598.                                 }
  599.                         }
  600.                         write_page_8bit(strdata,onepage,y1, oddy);
  601.                         IWDG_Feed();
  602.                         LCD_CS1 =0;
  603.                         LCD_CS2 =1;
  604.                         LCD_read_zheng_dat(strdata1,onepage, 0,64);
  605.                         if(corflag==0)
  606.                         {
  607.                                 for(i=0;i<64;i++)
  608.                                 {
  609.                                         strdata1[i] =Set_high_byte_reverse(strdata1[i], onerow);
  610.                                 }
  611.                         }
  612.                         else
  613.                         {
  614.                                 for(i=0;i<64;i++)
  615.                                 {
  616.                                         strdata1[i] =Set_low_byte_reverse(strdata1[i], onerow);
  617.                                 }
  618.                         }
  619.                         write_page_8bit(strdata1,onepage,0, 64);
  620.                         IWDG_Feed();
  621.                         LCD_CS1 =1;
  622.                         LCD_CS2 =0;
  623.                         LCD_read_zheng_dat(strdata2,onepage, 0,andy);
  624.                         if(corflag==0)
  625.                         {
  626.                                 for(i=0;i<andy;i++)
  627.                                 {
  628.                                         strdata2[i] =Set_high_byte_reverse(strdata2[i], onerow);
  629.                                 }
  630.                         }
  631.                         else
  632.                         {
  633.                                 for(i=0;i<andy;i++)
  634.                                 {
  635.                                         strdata2[i] =Set_low_byte_reverse(strdata2[i], onerow);
  636.                                 }
  637.                         }
  638.                         write_page_8bit(strdata2,onepage,0, andy);     ///////////////////////////////////  
  639.                         IWDG_Feed();
  640.                        
  641.                 }
  642.                 else if((y1>63)&&(y1<128)&&(y2<128))        ///////第 2  屏
  643.                 {
  644.                         LCD_CS1 =0;
  645.                         LCD_CS2 =1;
  646.                         LCD_read_zheng_dat(strdata,onepage, y1-64,ylen);
  647.                         if(corflag==0)
  648.                         {
  649.                                 for(i=0;i<ylen;i++)
  650.                                 {
  651.                                         strdata[i] =Set_high_byte_reverse(strdata[i], onerow);
  652.                                 }
  653.                         }
  654.                         else
  655.                         {
  656.                                 for(i=0;i<ylen;i++)
  657.                                 {
  658.                                         strdata[i] =Set_low_byte_reverse(strdata[i], onerow);
  659.                                 }
  660.                         }
  661.                         write_page_8bit(strdata,onepage,y1-64, ylen);     //先把一整页字节取出来 后再处理   
  662.                         IWDG_Feed();
  663.                 }
  664.                 else if((y1>63)&&(y1<128)&&(y2>=128))          //////2  3
  665.                 {
  666.                         oddy =128-y1;
  667.                         andy =ylen-oddy;
  668.                         LCD_CS1 =0;
  669.                         LCD_CS2 =1;
  670.                         LCD_read_zheng_dat(strdata,onepage, y1-64,oddy);
  671.                         if(corflag==0)
  672.                         {
  673.                                 for(i=0;i<oddy;i++)
  674.                                 {
  675.                                         strdata[i] =Set_high_byte_reverse(strdata[i], onerow);
  676.                                 }
  677.                         }
  678.                         else
  679.                         {
  680.                                 for(i=0;i<oddy;i++)
  681.                                 {
  682.                                         strdata[i] =Set_low_byte_reverse(strdata[i], onerow);
  683.                                 }
  684.                         }
  685.                         write_page_8bit(strdata,onepage,y1-64, oddy);
  686.                        
  687.                         LCD_CS1 =1;
  688.                         LCD_CS2 =0;
  689.                         LCD_read_zheng_dat(strdata1,onepage, 0,andy);
  690.                         if(corflag==0)
  691.                         {
  692.                                 for(i=0;i<andy;i++)
  693.                                 {
  694.                                         strdata1[i] =Set_high_byte_reverse(strdata1[i], onerow);
  695.                                 }
  696.                         }
  697.                         else
  698.                         {
  699.                                 for(i=0;i<andy;i++)
  700.                                 {
  701.                                         strdata1[i] =Set_low_byte_reverse(strdata1[i], onerow);
  702.                                 }
  703.                         }
  704.                         write_page_8bit(strdata1,onepage,0, andy);
  705.                         IWDG_Feed();
  706.                 }
  707.                 else
  708.                 {
  709.                         LCD_CS1 =1;
  710.                         LCD_CS2 =0;       
  711.                         LCD_read_zheng_dat(strdata,onepage, y1-128,ylen);
  712.                         if(corflag==0)
  713.                         {
  714.                                 for(i=0;i<ylen;i++)
  715.                                 {
  716.                                         strdata[i] =Set_high_byte_reverse(strdata[i], onerow);
  717.                                 }
  718.                         }
  719.                         else
  720.                         {
  721.                                 for(i=0;i<ylen;i++)
  722.                                 {
  723.                                         strdata[i] =Set_low_byte_reverse(strdata[i], onerow);
  724.                                 }
  725.                         }
  726.                         write_page_8bit(strdata,onepage,y1-128, ylen);
  727.                         IWDG_Feed();
  728.                 }
  729. }
  730. ////////////////////////////////////////
  731. //     函数名 ：display_reverse_cor
  732. //     功能   ：反色显示
  733. // display_onepage_reverse_cor(u8 onepage,u8 y1,u8 len)
  734. //  LCD_read_n_dat(u8 *buffer,u8 page,u8 y,u8 n)
  735. // display_lossonepage_revcor(u8 onepage,u8 onerow,u8 y1,u8 ylen,u8 corflag)
  736. ///////////////////////////////////////
  737. void display_reverse_cor(u8 x1,u8 y1,u8 x2,u8 y2)
  738. {

  740.         u8 i;
  741.         int xlen;       // x长度
  742.         int ylen;       //y 长度
  743.         u8 temp;
  744.         u8 wholepage1;   // 是否是处在整页的开始
  745.         u8 wholepage2;
  746.         u8 wholepage;
  747.         u8 remainrow1;   
  748. //        u8 remainrow2;
  749.         u8 whererow1;
  750.         u8 whererow2;
  751.         u8 temppage;

  753.        
  754.         if(y1>y2)
  755.         {
  756.                 temp =y1;
  757.                 y1 =y2;
  758.                 y2 =temp;
  759.         }
  760.         if(x1>x2)
  761.         {
  762.                 temp =x1;
  763.                 x1 =x2;
  764.                 x2 =temp;
  765.         }


  768.         xlen = x2-x1+1;
  769.         ylen = (y2-y1)+1;
  770.         wholepage1 =x1/8;       //
  771.         wholepage2 =x2/8;   //
  772.         whererow1 =x1%8;           //是否是整页的起始
  773.         whererow2 =(x2+1)%8;

  775.         if(xlen==8)               // 如果是一个字节
  776.         {
  777.                 if(whererow1==0)              //如果是整页
  778.                 {
  779.                         IWDG_Feed();
  780.                         display_onepage_reverse_cor(wholepage1,y1, ylen);
  781.                 }
  782.                 else                     //如果不是
  783.                 {
  784.                         IWDG_Feed();
  785.                         remainrow1 = 8-whererow1;
  786.                         display_lossonepage_revcor( wholepage1, remainrow1,y1, ylen, 0);
  787.                         display_lossonepage_revcor( wholepage2, whererow2, y1,ylen, 1);
  788.                 }
  789.         }                        //多余一个字节
  790.         else if(xlen>8)        
  791.         {
  792.                

  794.                 if((whererow1==0)&&(whererow2==0))
  795.                 {
  796.                         wholepage = xlen/8;
  797.                         for(i=0;i<wholepage;i++)
  798.                         {
  799.                                 display_onepage_reverse_cor(wholepage1+i,y1, ylen);
  800.                         }
  801.                 }
  802.                 else
  803.                 {
  804.                         remainrow1 = 8-whererow1;        ////首页行数    末页行数是whererow2
  805.                 //        remainrow2 = 8-whererow2;
  806.                         temppage = xlen-(remainrow1+whererow2);   //判断有几个整页
  807.                         if(temppage>=8)
  808.                         wholepage = temppage/8;
  809.                         else wholepage=0;
  810.                         IWDG_Feed();
  811.                         display_lossonepage_revcor( wholepage1, remainrow1,y1, ylen, 0);   //上半部分
  812.                        
  813.                         for(i=0;i<wholepage;i++)                          //中间整页部分
  814.                         {
  815.                                 display_onepage_reverse_cor(wholepage1+1+i,y1, ylen);
  816.                         }
  817.                         IWDG_Feed();
  818.                         display_lossonepage_revcor( wholepage2, whererow2, y1,ylen, 1);   //下半部分

  820.                         ///////////////////////////////////////////////////////////////
  821.                 }

  823.         }

  825. }
  826. ////////////////////////////////////////清屏
  827. //
  828. // write_wherepage_8bit(u8 data,u8 page,u8 y)
  829. /////////////////////////////////////////
  830. void LCD_clear(void)
  831. {
  832.         u16 count;
  833.         u8 page,temp=1,num;

  835.         LCD_CS1=LCD_CS2=0;
  836.         for(num=0;num<3;num++)
  837.         {       
  838. //                LCD_write_command(0xc0);             ////////////行显示
  839.                 for(page=0xb8;page<0xc0;page++)
  840.                 {
  841.                         LCD_write_command(0xc0);
  842.                         LCD_write_command(page);
  843.                         for(count=64;count>0;count--)
  844.                         {
  845.                                 LCD_write_data(0x00);
  846.                         }
  847.                 }
  848.                 LCD_CS1=LCD_CS2;
  849.                 LCD_CS2=temp;
  850.                 temp=LCD_CS1;
  851.        
  852.         }
  853. }
  854. ///////////////////////////////////////////////////////
  855. //    在一屏内指定的页指定的列写n列数据
  856. //函数名： write_page_8bit
  857. ///////////////////////////////////////////////////////
  858. void write_page_8bit(u8 *buffer,u8 page,u8 y,u8 n)
  859. {
  860.         u8 i;
  861.         LCD_write_command(BEGIN_PAGE+page);
  862.         LCD_write_command(BEGIN_Y+y);
  863.         for(i=0;i<n;i++)
  864.         {
  865.                 LCD_write_data(*buffer);
  866.                 buffer++;
  867.         }
  868. }


  871. ////////////////////////////////////////////////////////
  872. // 函数名：write_xy_piont
  873. // 功能： 在指定的行和列 画一个点或者删除一个点
  874. // flag:  0  删除一个点 ，1  画一个点
  875. // CS1 CS2 :00     ,01    ,10  
  876. ////////////////////////////////////////////////////////
  877. void write_xy_point(u8 x,u8 y,u8 flag)
  878. {
  879.   u8 oddwei;
  880.         u8 wholepage;
  881.         u8 rowdata;
  882.         rowdata=0;
  883.         wholepage=x/8;             //行所在的页数
  884.         oddwei=x%8;                //所在页数的第几页
  885.         if(y<64)
  886.         {
  887.                 LCD_CS1=0;
  888.                 LCD_CS2=0;
  889.                 LCD_write_command(BEGIN_PAGE+wholepage);
  890.                 LCD_write_command(BEGIN_Y+y);
  891. //                checkbusy();
  892.                 rowdata= LCD_read_data();
  893.                 if(flag==1)
  894.                 rowdata |= 1<<oddwei;
  895.                 else
  896.                 rowdata &=~(1<<oddwei);
  897.                 write_page_8bit(&rowdata,wholepage,y,1);
  898. //                LCD_write_data(rowdata);
  899.                
  900.         }
  901.         else if((y>=64)&&(y<128))
  902.         {
  903.                 LCD_CS1=0;
  904.                 LCD_CS2=1;
  905.                 LCD_write_command(BEGIN_PAGE+wholepage);
  906.                 LCD_write_command(BEGIN_Y+y-64);
  907. //                checkbusy();
  908.                 rowdata= LCD_read_data();
  909.                 if(flag==1)
  910.                 rowdata |= 1<<oddwei;
  911.                 else
  912.                 rowdata &=~(1<<oddwei);
  913.                 write_page_8bit(&rowdata,wholepage,y-64,1);
  914. //                LCD_write_data(rowdata);
  915.                
  916.         }
  917.         else
  918.         {
  919.                 LCD_CS1=1;
  920.                 LCD_CS2=0;
  921.                 LCD_write_command(BEGIN_PAGE+wholepage);
  922.                 LCD_write_command(BEGIN_Y+y-128);
  923. //                checkbusy();
  924.                 rowdata= LCD_read_data();
  925.                 if(flag==1)
  926.                 rowdata |= 1<<oddwei;
  927.                 else
  928.                 rowdata &=~(1<<oddwei);
  929.                 write_page_8bit(&rowdata,wholepage,y-128,1);
  930. //                LCD_write_data(rowdata);

  932.         }
  933. }
  934. /////////////////////////////////////////////////////////////////
  935. //       画圆
  936. //
  937. //
  938. ///////////////////////////////////////////////////////////////
  939. void draw_circle(u8 x0,u8 y0,u8 r,u8 flagg)
  940. {
  941.         int a,b;
  942.         int di;
  943.         a=0;b=r;          
  944.         di=3-(r<<1);             //
  945.         while(a<=b)
  946.         {
  947.                 write_xy_point(x0-b,y0-a,flagg);             //3           
  948.                 write_xy_point(x0+b,y0-a,flagg);             //0           
  949.                 write_xy_point(x0-a,y0+b,flagg);             //1      
  950.                 write_xy_point(x0-b,y0-a,flagg);             //7           
  951.                 write_xy_point(x0-a,y0-b,flagg);             //2            
  952.                 write_xy_point(x0+b,y0+a,flagg);             //4               
  953.                 write_xy_point(x0+a,y0-b,flagg);             //5
  954.                 write_xy_point(x0+a,y0+b,flagg);             //6
  955.                 write_xy_point(x0-b,y0+a,flagg);            
  956.                 a++;
  957.                 //Bresenham   
  958.                 if(di<0)di +=4*a+6;          
  959.                 else
  960.                 {
  961.                         di+=10+4*(a-b);   
  962.                         b--;
  963.                 }
  964.                 write_xy_point(x0+a,y0+b,flagg);
  965.         }
  966. }
  967. ////////////////////////////////////////////////////////////////
  968. //  函数名：  draw_line
  969. //  功能  ：  在任意两点间画一条直线或者删除一条直线
  970. //Bresenham算法-直线光栅法算法  flag : 0  删除，1 画一条直线
  971. ////////////////////////////////////////////////////////////////
  972. void draw_line(u8 x0,u8 y0,u8 x1,u8 y1,u8 flag)
  973. {
  974.         u16 t;
  975.         int nowrow,nowcol;   //   行 列
  976.         int incx,incy;    //   基准
  977.         int distance_x,distance_y,distance;   
  978.         int xerr=0,yerr=0;
  979.        
  980.         nowrow=x0;   
  981.         nowcol=y0;
  982.         distance_x=(int)x1-(int)x0+1;
  983.         distance_y=(int)y1-(int)y0+1;
  984.         if(distance_x>0)incx=1;   //  判断x1 yu x0 大小，然后给基准x赋值
  985.         else if(distance_x==0)incx=0;
  986.         else
  987.         {
  988.                 incx=-1;
  989.                 distance_x=(-distance_x)+2;
  990.         }
  991.         if(distance_y>0)incy=1;  //判断y1 与 y0 大小，然后给基准x赋值
  992.         else if(distance_y==0)incy=0;
  993.         else
  994.         {
  995.                 incy=-1;
  996.                 distance_y=(-distance_y)+2;
  997.         }
  998.         if(distance_x>distance_y)distance=distance_x;
  999.         else distance=distance_y;
  1000.         for(t=0;t<distance+1;t++)
  1001.         {
  1002.                 write_xy_point(nowrow,nowcol,flag);
  1003.                 xerr+=distance_x;
  1004.                 yerr+=distance_y;
  1005.                 if(xerr>distance)
  1006.                 {
  1007.                         xerr-=distance;
  1008.                         nowrow+=incx;       
  1009.                 }
  1010.                 if(yerr>distance)
  1011.                 {
  1012.                         yerr-=distance;
  1013.                         nowcol+=incy;       
  1014.                 }
  1015.         }       
  1016. }
  1017. //////////////////////////////////////////////////////
  1018. //   函数名： draw_dect
  1019. //   功能  ： 画一个矩形（x1,y1）（x2,y2）或者删除一个矩形
  1020. ////////////////////////////////////////////////////////
  1021. void draw_dect(u8 x1,u8 y1,u8 x2,u8 y2,u8 flag)
  1022. {
  1023.         draw_line(x1,y1,x1,y2,flag);
  1024.         draw_line(x1,y2,x2,y2,flag);
  1025.         draw_line(x2,y1,x2,y2,flag);
  1026.         draw_line(x1,y1,x2,y1,flag);
  1027. }
  1028. /////////////////////////////////////////////////////
  1029. //   函数名：fill_rect
  1030. //   功能  ：填充指定的矩形区域
  1031. ////////////////////////////////////////////////////
  1032. void fill_rect(u8 x0,u8 y0,u8 x1,u8 y1,u8 flag)
  1033. {
  1034.         u8 i;
  1035.         u8 distance_x;
  1036.         if(x0>x1)
  1037.         {
  1038.                 distance_x=x0-x1;
  1039.                 for(i=0;i<=distance_x;i++)       
  1040.                 {
  1041.                         draw_line(x1+i,y0,x1+i,y1,flag);       
  1042.                 }
  1043.         }
  1044.         else
  1045.         {
  1046.                 distance_x=x1-x0;
  1047.                 for(i=0;i<=distance_x;i++)       
  1048.                 {
  1049.                         draw_line(x0+i,y0,x0+i,y1,flag);       
  1050.                 }
  1051.         }       
  1052. }
  1053. ////////////////////////////////////////////////////////
  1054. //   函数名： write_xy_8bit
  1055. //   功能  ：在任意的x,y点写一列数据
  1056. //   为在任意的位置写字符和汉字做准备
  1057. ////////////////////////////////////////////////////////
  1058. void write_xy_8bit(u8 datt,u8 x,u8 y)
  1059. {
  1060.         static u8 tempdat;
  1061.         static u8 read_datt;
  1062.         u8 wholepage,frontpage_wei,nextpage_wei,whererow;
  1063.         read_datt=0;
  1064.         tempdat=datt;
  1065.         wholepage=x/8;                                 ////// 行所在的当前页
  1066.         whererow=x%8;                                                                 /////// x所在页的第几行
  1067.         frontpage_wei=8-whererow;                      /////// 当前页需要用到几行
  1068.         nextpage_wei=8-frontpage_wei;                //////下一页需要用到几行
  1069.         LCD_write_command(BEGIN_PAGE+wholepage);         /////读当前页数据前先写入地址
  1070.         LCD_write_command(BEGIN_Y+y);
  1071.         read_datt= LCD_read_data();                  ////// 读取当前页数据
  1072.         read_datt&=0xff>>frontpage_wei;
  1073.         tempdat=tempdat<<whererow;
  1074.         tempdat|= read_datt;
  1075.         write_page_8bit(&tempdat,wholepage,y,1);
  1076.         tempdat=0;
  1077.         read_datt=0;
  1078.         tempdat=datt;
  1079.         LCD_write_command(BEGIN_PAGE+wholepage+1);         /////读取下一页数据
  1080.         LCD_write_command(BEGIN_Y+y);
  1081.         read_datt= LCD_read_data();                  ////// 读取数据
  1082.         read_datt &= 0xff<<nextpage_wei;
  1083.         tempdat=tempdat>>frontpage_wei;
  1084.         tempdat |=read_datt;
  1085.         write_page_8bit(&tempdat,wholepage+1,y,1);       
  1086. }
  1087. ///////////////////////////////////////////////////////////////
  1088. //       函数名： write_xy_nbit
  1089. //                         功  能 ：在任意的位置写 N 列数据
  1090. //   LCD_read_zheng_dat(u8 *buffer,u8 page,u8 y,u8 n)
  1091. //////////////////////////////////////////////////////////////
  1092. void write_xy_n8bit(u8 *pbuff,u8 x,u8 y,u8 len)
  1093. {
  1094.         static u8 i;
  1095.         u8 tempdat[35];
  1096.         u8 read_datt[35];
  1097.         u8 wholepage,frontpage_wei,nextpage_wei,whererow;

  1099.         wholepage=x/8;                                 ////// 行所在的当前页
  1100.         whererow=x%8;                                                                 /////// x所在页的第几行
  1101.         frontpage_wei=8-whererow;                      /////// 当前页需要用到几行
  1102.         nextpage_wei=8-frontpage_wei;                //////下一页需要用到几行
  1103.         
  1104. /*        for(i=0;i<35;i++)
  1105.         {
  1106.                 read_datt[i]=0;
  1107.                 tempdat[i]=0;
  1108.         }*/
  1109.         for(i=0;i<len;i++)
  1110.         tempdat[i]=pbuff[i];
  1111.         LCD_read_zheng_dat(read_datt,wholepage,y,len);
  1112.         for(i=0;i<len;i++)
  1113.         {
  1114.                 read_datt[i]&=0xff>>frontpage_wei;
  1115.                 tempdat[i]=tempdat[i]<<whererow;
  1116.                 tempdat[i]|= read_datt[i];
  1117.         }
  1118. //        LCD_write_command(BEGIN_ROW);
  1119.         write_page_8bit(tempdat,wholepage,y,len);

  1121. /*        for(i=0;i<len;i++)
  1122.         {
  1123.                 read_datt[i]=0;
  1124.                 tempdat[i]=0;
  1125.         }*/
  1126.         for(i=0;i<len;i++)
  1127.         {
  1128.                 tempdat[i]=pbuff[i];

  1130.         }
  1131.         LCD_read_zheng_dat(read_datt,wholepage+1,y,len);

  1133.         for(i=0;i<len;i++)
  1134.         {
  1135.                 read_datt[i]&=0xff<<nextpage_wei;
  1136.                 tempdat[i]=tempdat[i]>>frontpage_wei;
  1137.                 tempdat[i]|= read_datt[i];
  1138.         }
  1139. //        LCD_write_command(BEGIN_ROW);
  1140.         write_page_8bit(tempdat,wholepage+1,y,len);       
  1141. }
  1142. ///////////////////////////////////////////////////////////////
  1143. //   函数名：write_angwhere_English
  1144. //   功能  ：在任意的（x,y） 的位置处写一个字符
  1145. //  一个字符占16个字节，上下8个字节(8*16)
  1146. ////////////////////////////////////////////////////////////////
  1147. void write_8x16_English(u8 *pps,u8 x,u8 y)  
  1148. {
  1149.         u8 i;
  1150.         u8 andwei;            // y行加上8个字节后新的行数                  
  1151.         u8 oddwei;           
  1152.         u8 oddwei1;            
  1153.         u8 tempwei;         
  1154.         u8 tempwei1;
  1155.         andwei=y+7;

  1157.         if(andwei<64)            //位于第一屏
  1158.         {
  1159.                 LCD_CS1=0;
  1160.                 LCD_CS2=0;
  1161.                 for(i=0;i<8;i++)
  1162.                 {
  1163.                         write_xy_8bit(*pps,x,y+i);
  1164.                         write_xy_8bit(*(pps+8),x+8,y+i);
  1165.                         pps++;
  1166.                 }
  1167.        
  1168.         }
  1169.         else if((y<64)&&(andwei>=64))    //位于第一屏和第二屏之间
  1170.         {
  1171.                 oddwei=andwei-63;           //  位于第2屏的位数
  1172.                 tempwei=8-oddwei;           //  位于第1屏的位数
  1173.                 LCD_CS1=0;
  1174.                 LCD_CS2=0;
  1175.                 for(i=0;i<tempwei;i++)      //位于第1屏
  1176.                 {
  1177.                         write_xy_8bit(*pps,x,y+i);
  1178.                         write_xy_8bit(*(pps+8),x+8,y+i);
  1179.                         pps++;
  1180.                 }
  1181.        
  1182.                 LCD_CS1=0;
  1183.                 LCD_CS2=1;
  1184.                 for(i=0;i<oddwei;i++)     //位于第2屏
  1185.                 {
  1186.                         write_xy_8bit(*(pps),x,i);
  1187.                         write_xy_8bit(*(pps+8),x+8,i);
  1188.                         pps++;
  1189.                 }
  1190.        
  1191.         }
  1192.         else if((y>=64)&&(andwei<128))     //位于第二屏中
  1193.         {
  1194.                 LCD_CS1=0;
  1195.                 LCD_CS2=1;
  1196.                 for(i=0;i<8;i++)
  1197.                 {
  1198.                         write_xy_8bit(*pps,x,y+i-64);
  1199.                         write_xy_8bit(*(pps+8),x+8,y+i-64);
  1200.                         pps++;
  1201.                 }
  1202.         }
  1203.         else if((y>63)&&(y<128)&&(andwei>=128))    //位于第2屏和第3屏之间
  1204.         {
  1205.                 oddwei1=andwei-127;          //位于第3屏的位数
  1206.                 tempwei1=8-oddwei1;           //位于第2屏
  1207.                 LCD_CS1=0;
  1208.                 LCD_CS2=1;
  1209.                 for(i=0;i<tempwei1;i++)       //位于第2屏
  1210.                 {
  1211.                         write_xy_8bit(*pps,x,y+i-64);
  1212.                         write_xy_8bit(*(pps+8),x+8,y+i-64);
  1213.                         pps++;
  1214.                 }
  1215.                 LCD_CS1=1;
  1216.                 LCD_CS2=0;
  1217.                 for(i=0;i<oddwei1;i++)        //位于第3屏
  1218.                 {
  1219.                         write_xy_8bit(*pps,x,i);
  1220.                         write_xy_8bit(*(pps+8),x+8,i);
  1221.                         pps++;
  1222.                 }
  1223.         }
  1224.         else if((y>=128)&&(andwei<192))   //位于第3屏
  1225.         {
  1226.                 LCD_CS1=1;
  1227.                 LCD_CS2=0;
  1228.                 for(i=0;i<8;i++)
  1229.                 {
  1230.                         write_xy_8bit(*pps,x,y+i-128);
  1231.                         write_xy_8bit(*(pps+8),x+8,y+i-128);
  1232.                         pps++;
  1233.                 }
  1234.                
  1235.         }       
  1236.         else if((y<192)&&(andwei>=192))
  1237.         {
  1238.                 LCD_CS1=0;
  1239.                 LCD_CS2=0;
  1240.                 for(i=0;i<8;i++)
  1241.                 {
  1242.                         write_xy_8bit(*pps,x+16,i);
  1243.                         write_xy_8bit(*(pps+8),x+24,i);
  1244.                         pps++;
  1245.                 }
  1246.         }
  1247. }
  1248. ////////////////////////////////////////////////////////////
  1249. //     函数名：write_7x8_English
  1250. //     共能  ：在任意的位置显示一个字符(大小为7x8)
  1251. //     共占用8个字节
  1252. //     write_page_8bit(u8 *buffer,u8 page,u8 y,u8 n)
  1253. ////////////////////////////////////////////////////////////
  1254. void write_7x8_English(u8 *pps,u8 x,u8 y)
  1255. {
  1256.         u8 andwei;            // y行加上8个字节后新的行数                  
  1257.         u8 oddwei;                     
  1258.         u8 tempwei;         
  1259.         u8 oddpage;
  1260.         u8 wholepage;
  1261.        
  1262.         oddpage = x%8;
  1263.         wholepage = x/8;
  1264.         andwei=y+7;

  1266.         if(oddpage==0)
  1267.         {
  1268.                 if(andwei<64)            //位于第一屏
  1269.                 {
  1270.                         LCD_CS1=0;
  1271.                         LCD_CS2=0;
  1272.                         write_page_8bit(pps,wholepage,y,8);

  1274.                
  1275.                 }
  1276.                 else if((y<64)&&(andwei>=64))    //位于第一屏和第二屏之间
  1277.                 {
  1278.                         oddwei=andwei-63;           //  位于第2屏的位数
  1279.                         tempwei=8-oddwei;           //  位于第1屏的位数
  1280.                         LCD_CS1=0;
  1281.                         LCD_CS2=0;
  1282.                         write_page_8bit(pps,wholepage,y,tempwei);

  1284.                         LCD_CS1=0;
  1285.                         LCD_CS2=1;
  1286.                         write_page_8bit(pps+tempwei,wholepage,0,oddwei);

  1288.                 }
  1289.                 else if((y>=64)&&(andwei<128))     //位于第二屏中
  1290.                 {
  1291.                         LCD_CS1=0;
  1292.                         LCD_CS2=1;
  1293.                         write_page_8bit(pps,wholepage,y-64,8);

  1295.                 }
  1296.                 else if((y<128)&&(andwei>=128))    //位于第2屏和第3屏之间
  1297.                 {
  1298.                         oddwei=andwei-127;          //位于第3屏的位数
  1299.                         tempwei=8-oddwei;           //位于第2屏
  1300.                         LCD_CS1=0;
  1301.                         LCD_CS2=1;
  1302.                         write_page_8bit(pps,wholepage,y-64,tempwei);
  1303.                        
  1304.                         LCD_CS1=1;
  1305.                         LCD_CS2=0;
  1306.                         write_page_8bit(pps+tempwei,wholepage,0,oddwei);

  1308.                 }
  1309.                 else    //位于第3屏
  1310.                 {
  1311.                         LCD_CS1=1;
  1312.                         LCD_CS2=0;
  1313.                         write_page_8bit(pps,wholepage,y-128,8);
  1314.                 }       

  1316.         }
  1317.         else          //write_xy_nbit(u8 *pbuff,u8 x,u8 y,u8 len)
  1318.         {
  1319.                 if(andwei<64)            //位于第一屏
  1320.                 {
  1321.                         LCD_CS1=0;
  1322.                         LCD_CS2=0;
  1323.                         write_xy_n8bit(pps,x,y,8);
  1324. /*                        for(i=0;i<8;i++)
  1325.                         {
  1326.                                 write_xy_8bit(*pps,x,y+i);
  1327.                                 pps++;
  1328.                         }*/
  1329.                 }
  1330.                 else if((y<64)&&(andwei>=64))    //位于第一屏和第二屏之间
  1331.                 {
  1332.                         oddwei=andwei-63;           //  位于第2屏的位数
  1333.                         tempwei=8-oddwei;           //  位于第1屏的位数
  1334.                         LCD_CS1=0;
  1335.                         LCD_CS2=0;
  1336.                         write_xy_n8bit(pps,x,y,tempwei);
  1337. /*                        for(i=0;i<tempwei;i++)      //位于第1屏
  1338.                         {
  1339.                                 write_xy_8bit(*pps,x,y+i);
  1340.                                 pps++;
  1341.                         }*/
  1342.                
  1343.                         LCD_CS1=0;
  1344.                         LCD_CS2=1;
  1345.                         write_xy_n8bit(pps+tempwei,x,0,oddwei);
  1346. /*                        for(i=0;i<oddwei;i++)     //位于第2屏
  1347.                         {
  1348.                                 write_xy_8bit(*(pps),x,i);
  1349.                                 pps++;
  1350.                         }*/
  1351.                
  1352.                 }
  1353.                 else if((y>=64)&&(andwei<128))     //位于第二屏中
  1354.                 {
  1355.                         LCD_CS1=0;
  1356.                         LCD_CS2=1;
  1357.                         write_xy_n8bit(pps,x,y-64,8);
  1358. /*                        for(i=0;i<8;i++)
  1359.                         {
  1360.                                 write_xy_8bit(*pps,x,y+i-64);
  1361.                                 pps++;
  1362.                         }*/
  1363.                 }
  1364.                 else if((y<128)&&(andwei>=128))    //位于第2屏和第3屏之间
  1365.                 {
  1366.                         oddwei=andwei-127;          //位于第3屏的位数
  1367.                         tempwei=8-oddwei;           //位于第2屏
  1368.                         LCD_CS1=0;
  1369.                         LCD_CS2=1;
  1370.                         write_xy_n8bit(pps,x,y-64,tempwei);
  1371. /*                        for(i=0;i<tempwei;i++)       //位于第2屏
  1372.                         {
  1373.                                 write_xy_8bit(*pps,x,y+i-64);
  1374.                                
  1375.                                 pps++;
  1376.                         }*/
  1377.                         LCD_CS1=1;
  1378.                         LCD_CS2=0;
  1379.                         write_xy_n8bit(pps+tempwei,x,0,oddwei);
  1380. /*                        for(i=0;i<oddwei;i++)        //位于第3屏
  1381.                         {
  1382.                                 write_xy_8bit(*pps,x,i);
  1383.                        
  1384.                                 pps++;
  1385.                         }*/
  1386.                 }
  1387.                 else if(y>=128)   //位于第3屏
  1388.                 {
  1389.                         LCD_CS1=1;
  1390.                         LCD_CS2=0;
  1391.                         write_xy_n8bit(pps,x,y-128,8);
  1392. /*                        for(i=0;i<8;i++)
  1393.                         {
  1394.                                 write_xy_8bit(*pps,x,y+i-128);
  1395.                        
  1396.                                 pps++;
  1397.                         }*/
  1398.                        
  1399.                 }       

  1401. }
  1402. }
  1403. ////////////////////////////////////////////////////////////
  1404. //    函数名：display_str_en
  1405. //    功能  ：在任意地址显示字符串   7*8
  1406. //    read_bytes_fromZIC(u8 *pbuffer,u32 addr,u16 len)
  1407. //     tiao shi cheng gong
  1408. ////////////////////////////////////////////////////////////
  1409. void display_str_en8(u8 *text,u8 x,u8 y)
  1410. {
  1411.         u8 i=0;
  1412.         u32 address;
  1413.         u8 pbuffer[10];
  1414.         u8 temp_y;

  1416.         while(text[i]>0)                    //先判断字符的ASCII码是否为0，
  1417.         {
  1418. /*                        LCD_CS1 = 0;
  1419.         LCD_CS2 = 0;
  1420.         LCD_write_command(0xc0);       
  1421.                 LCD_CS1 = 0;
  1422.         LCD_CS2 = 1;
  1423.         LCD_write_command(0xc0);
  1424.                 LCD_CS1 = 1;
  1425.         LCD_CS2 = 0;*/
  1426.         LCD_write_command(0xc0);
  1427.                 temp_y=y+8;                       //判断剩余列数是否可以写完一个字符
  1428.                 if(temp_y>192)                    //如果剩余列数小于8
  1429.                 {
  1430.                         x+=8;                           // 行地址增加一页，列地址为0
  1431.                         y=0;
  1432.           }
  1433.                 address=(text[i]-0x20)*8+0x66c0;  //取点阵地址
  1434.                 read_bytes_fromZIC(pbuffer,address,8);   //取点阵数据，存储在 pbuffer
  1435.                 write_7x8_English(pbuffer, x, y);      //xian shi
  1436.                 i+=1;                                 //字符地址加1，
  1437.                 y+=8;                                // 列数加8
  1438.                 IWDG_Feed();
  1439.         }
  1440. }
  1441. /////////////////////////////////////////////////////////
  1442. //     函数名： display_str_en16
  1443. //     功能  ： 显示 8*16字符
  1444. //   tiaoshi cheng gong
  1445. ///////////////////////////////////////////////////
  1446. void display_str_en16(u8 *text,u8 x,u8 y)
  1447. {
  1448.         u8 i=0;
  1449.         u32 address;
  1450.         u8 pbuffer[18];
  1451.         u8 temp_y;
  1452.         while(text[i]>0)                    //先判断字符的ASCII码是否为0，
  1453.         {
  1454.                 temp_y=y+16;                       //判断剩余列数是否可以写完一个字符
  1455.                 if(temp_y>191)                    //如果剩余列数小于8
  1456.                 {
  1457.                         x+=8;                           // 行地址增加一页，列地址为0
  1458.                         y=0;
  1459.           }
  1460.                 address=(u32)((text[i]-0x20)*16+0x3b7c0);  //取点阵地址
  1461.                 read_bytes_fromZIC(pbuffer,address,16);   //取点阵数据，存储在 pbuffer
  1462.                 write_8x16_English(pbuffer, x, y);      //xian shi
  1463.                 i+=1;                                 //字符地址加1，
  1464.                 y+=8;                                // 列数加8
  1465.         }
  1466. }
  1467. ////////////////////////////////////////////////////////////
  1468. //   函数名：write_xy_ch
  1469. //   功能  ：在任意的行和列写一个汉字
  1470. //   1个汉字占用32个字节，占16行16列
  1471. //     tiao shi cheng gong
  1472. //    write_page_8bit(u8 *buffer,u8 page,u8 y,u8 n)
  1473. ////////////////////////////////////////////////////////////
  1474. void write_xy_15x16_ch(u8 *p,u8 x,u8 y)
  1475. {
  1476.         u8 wholepage;
  1477.         u8 oddpage;
  1478.         u8 andwei=0;
  1479.         u8 oddwei=0;
  1480.         u8 tempwei=0;
  1481.         oddpage = x%8;
  1482.         wholepage = x/8;
  1483.         andwei=y+15;

  1485.         if(oddpage==0)
  1486.         {
  1487.                 if(andwei<64)               //在第1屏中
  1488.                 {
  1489.                         LCD_CS1=0;
  1490.                         LCD_CS2=0;
  1491.                         write_page_8bit(p,wholepage,y,16);         //上左字节
  1492.                         write_page_8bit(p+16,wholepage+1,y,16);  //下左字节

  1494.                 }
  1495.                 else if((y<64)&&(andwei>=64))   //在第1屏和第2屏之间
  1496.                 {
  1497.                         oddwei=andwei-63;
  1498.                         tempwei=16-oddwei;
  1499.                         LCD_CS1=0;
  1500.                         LCD_CS2=0;
  1501.                         write_page_8bit(p,wholepage,y,tempwei);
  1502.                         write_page_8bit(p+16,wholepage+1,y,tempwei);

  1504.                         LCD_CS1=0;
  1505.                         LCD_CS2=1;
  1506.                         write_page_8bit(p+tempwei,wholepage,0,oddwei);
  1507.                         write_page_8bit((p+16+tempwei),wholepage+1,0,oddwei);       

  1509.                 }
  1510.                 else if((y>=64)&&(andwei<128))   //位于第2屏中
  1511.                 {
  1512.                         LCD_CS1=0;
  1513.                         LCD_CS2=1;
  1514.                         write_page_8bit(p,wholepage,y-64,16);
  1515.                         write_page_8bit(p+16,wholepage+1,y-64,16);       
  1516.                 }
  1517.                 else if((y<128)&&(andwei>=128))    //位于第2屏和第3屏之间
  1518.                 {
  1519.                         oddwei=andwei-127;
  1520.                         tempwei=16-oddwei;
  1521.                         LCD_CS1=0;
  1522.                         LCD_CS2=1;
  1523.                         write_page_8bit(p,wholepage,y-64,tempwei);
  1524.                         write_page_8bit(p+16,wholepage+1,y-64,tempwei);

  1526.                         LCD_CS1=1;
  1527.                         LCD_CS2=0;
  1528.                         write_page_8bit(p+tempwei,wholepage,0,oddwei);
  1529.                         write_page_8bit(p+16+tempwei,wholepage+1,0,oddwei);       

  1531.                 }
  1532.                 else if(y>=128)    //位于第3屏中
  1533.                 {
  1534.                         LCD_CS1=1;
  1535.                         LCD_CS2=0;
  1536.                         write_page_8bit(p,wholepage,y-128,16);
  1537.                         write_page_8bit(p+16,wholepage+1,y-128,16);
  1538.                 }
  1539.         }
  1540.         else
  1541.         {
  1542.                 if(andwei<64)               //在第1屏中
  1543.                 {
  1544.                         LCD_CS1=0;
  1545.                         LCD_CS2=0;
  1546.                         write_xy_n8bit(p,x,y,16);
  1547.                         write_xy_n8bit(p+16,x+8,y,16);
  1548. /*                        for(i=0;i<8;i++)
  1549.                         {
  1550.                                 write_xy_8bit(*p,x,y+i);         //上左字节
  1551.                                 write_xy_8bit(*(p+8),x,y+8+i);   //上右字节
  1552.                                 write_xy_8bit(*(p+16),x+8,y+i);  //下左字节
  1553.                                 write_xy_8bit(*(p+24),x+8,y+8+i); //下右字节
  1554.                                 p++;       
  1555.                         }*/
  1556.                                
  1557.                 }
  1558.                 else if((y<64)&&(andwei>=64))   //在第1屏和第2屏之间
  1559.                 {
  1560.                         oddwei=andwei-63;
  1561.                         tempwei=16-oddwei;
  1562.                         LCD_CS1=0;
  1563.                         LCD_CS2=0;
  1564.                         write_xy_n8bit(p,x,y,tempwei);
  1565.                         write_xy_n8bit(p+16,x+8,y,tempwei);
  1566.         /*                for(i=0;i<tempwei;i++)
  1567.                         {
  1568.                                 write_xy_8bit(*p,x,y+i);
  1569.                                 write_xy_8bit(*(p+16),x+8,y+i);
  1570.                                 p++;       
  1571.                         }*/
  1572.                         LCD_CS1=0;
  1573.                         LCD_CS2=1;
  1574.                         write_xy_n8bit(p+tempwei,x,0,oddwei);
  1575.                         write_xy_n8bit(p+16+tempwei,x+8,0,oddwei);
  1576. /*                        for(i=0;i<oddwei;i++)
  1577.                         {
  1578.                                 write_xy_8bit(*p,x,i);
  1579.                                 write_xy_8bit(*(p+16),x+8,i);       
  1580.                                 p++;
  1581.                         }*/       
  1582.                 }
  1583.                 else if((y>=64)&&(andwei<128))   //位于第2屏中
  1584.                 {
  1585.                         LCD_CS1=0;
  1586.                         LCD_CS2=1;
  1587.                         write_xy_n8bit(p,x,y-64,16);
  1588.                         write_xy_n8bit(p+16,x+8,y-64,16);
  1589. /*                        for(i=0;i<8;i++)
  1590.                         {
  1591.                                 write_xy_8bit(*p,x,y+i-64);
  1592.                                 write_xy_8bit(*(p+8),x,y+i-56);
  1593.                                 write_xy_8bit(*(p+16),x+8,y+i-64);
  1594.                                 write_xy_8bit(*(p+24),x+8,y+i-56);       
  1595.                                 p++;
  1596.                         }                */
  1597.                 }
  1598.                 else if((y<128)&&(andwei>=128))    //位于第2屏和第3屏之间
  1599.                 {
  1600.                         oddwei=andwei-127;
  1601.                         tempwei=16-oddwei;
  1602.                         LCD_CS1=0;
  1603.                         LCD_CS2=1;
  1604.                         write_xy_n8bit(p,x,y-64,tempwei);
  1605.                         write_xy_n8bit(p+16,x+8,y-64,tempwei);
  1606. /*                        for(i=0;i<tempwei;i++)
  1607.                         {
  1608.                                 write_xy_8bit(*p,x,y+i-64);
  1609.                                 write_xy_8bit(*(p+16),x+8,y+i-64);
  1610.                                 p++;       
  1611.                         }*/
  1612.                         LCD_CS1=1;
  1613.                         LCD_CS2=0;
  1614.                         write_xy_n8bit(p+tempwei,x,0,oddwei);
  1615.                         write_xy_n8bit(p+16+tempwei,x+8,0,oddwei);
  1616. /*                        for(i=0;i<oddwei;i++)
  1617.                         {

  1619.                                 write_xy_8bit(*p,x,i);
  1620.                                 write_xy_8bit(*(p+16),x+8,i);       
  1621.                                 p++;
  1622.                         }        */
  1623.                 }
  1624.                 else if((y>=128)&&(andwei<192))    //位于第3屏中
  1625.                 {
  1626.                         LCD_CS1=1;
  1627.                         LCD_CS2=0;
  1628.                         write_xy_n8bit(p,x,y-128,16);
  1629.                         write_xy_n8bit(p+16,x+8,y-128,16);
  1630.         /*                for(i=0;i<8;i++)
  1631.                         {
  1632.                                 write_xy_8bit(*p,x,y+i-128);
  1633.                                 write_xy_8bit(*(p+8),x,y+i-120);
  1634.                                 write_xy_8bit(*(p+16),x+8,y+i-128);
  1635.                                 write_xy_8bit(*(p+24),x+8,y+i-120);       
  1636.                                 p++;
  1637.                         }        */
  1638.                 }
  1639.         }

  1641. }

  1643. /////////////////////////////////////////////////////
  1644. //     函数名：write_xy_11x12_ch
  1645. //     功能  ：在任意的地址写1个11x12的汉字
  1646. //     1个汉字占11列12行，24个字节
  1647. //   tiao shi cheng gong
  1648. //////////////////////////////////////////////////////
  1649. void write_xy_11x12_ch(u8 *p,u8 x,u8 y)
  1650. {
  1651.         u8 i;
  1652.         u8 andwei;
  1653.         u8 oddwei;
  1654.         u8 oddwei_1;
  1655.         u8 tempwei;
  1656.         u8 tempwei_1;
  1657.         andwei=y+11;
  1658.        
  1659.         if(andwei<64)          //在第1屏中
  1660.         {
  1661.                 LCD_CS1=0;
  1662.                 LCD_CS2=0;
  1663.                 for(i=0;i<12;i++)
  1664.                 {
  1665.                         write_xy_8bit(*p,x,y+i);       //上字节
  1666.                         write_xy_8bit(*(p+12),x+8,y+i);  //下字节
  1667.                         p++;       
  1668.                 }
  1669.                        
  1670.         }
  1671.         else if((y<64)&&(andwei>=64))   //在第1屏和第2屏之间
  1672.         {
  1673.                 oddwei=andwei-63;
  1674.                 tempwei=12-oddwei;
  1675.                 LCD_CS1=0;
  1676.                 LCD_CS2=0;
  1677.                 for(i=0;i<tempwei;i++)
  1678.                 {
  1679.                         write_xy_8bit(*p,x,y+i);
  1680.         //                writedata_8bit(*(p+8),x,y+8+i);
  1681.                         write_xy_8bit(*(p+12),x+8,y+i);
  1682.         //                writedata_8bit(*(p+24),x+8,y+8+i);
  1683.                         p++;       
  1684.                 }
  1685.                 LCD_CS1=0;
  1686.                 LCD_CS2=1;;
  1687.                 for(i=0;i<oddwei;i++)
  1688.                 {
  1689.         //                writedata_8bit(*p,x,y+i);
  1690.                         write_xy_8bit(*p,x,i);
  1691.         //                writedata_8bit(*(p+16),x+8,y+i);
  1692.                         write_xy_8bit(*(p+12),x+8,i);       
  1693.                         p++;
  1694.                 }       
  1695.         }
  1696.         else if((y>=64)&&(andwei<=128))   //位于第2屏中
  1697.         {
  1698.                 LCD_CS1=0;
  1699.                 LCD_CS2=1;
  1700.                 for(i=0;i<12;i++)
  1701.                 {
  1702.                         write_xy_8bit(*p,x,y+i-64);
  1703.                         write_xy_8bit(*(p+12),x+8,y+i-64);
  1704.                         p++;
  1705.                 }               
  1706.         }
  1707.         else if((y<128)&&(andwei>=128))    //位于第2屏和第3屏之间
  1708.         {
  1709.                 oddwei_1=andwei-127;
  1710.                 tempwei_1=12-oddwei_1;
  1711.                 LCD_CS1=0;
  1712.                 LCD_CS2=1;
  1713.                 for(i=0;i<tempwei_1;i++)
  1714.                 {
  1715.                         write_xy_8bit(*p,x,y+i-64);
  1716.         //                writedata_8bit(*(p+8),x,y+8+i);
  1717.                         write_xy_8bit(*(p+12),x+8,y+i-64);
  1718.         //                writedata_8bit(*(p+24),x+8,y+8+i);
  1719.                         p++;       
  1720.                 }
  1721.                 LCD_CS1=1;
  1722.                 LCD_CS2=0;;
  1723.                 for(i=0;i<oddwei_1;i++)
  1724.                 {
  1725.         //                writedata_8bit(*p,x,y+i);
  1726.                         write_xy_8bit(*p,x,i);
  1727.         //                writedata_8bit(*(p+16),x+8,y+i);
  1728.                         write_xy_8bit(*(p+12),x+8,i);       
  1729.                         p++;
  1730.                 }       
  1731.         }
  1732.         else if((y>=128)&&(andwei<192))    //位于第3屏中
  1733.         {
  1734.                 LCD_CS1=1;
  1735.                 LCD_CS2=0;
  1736.                 for(i=0;i<12;i++)
  1737.                 {
  1738.                         write_xy_8bit(*p,x,y+i-128);
  1739.                         write_xy_8bit(*(p+12),x+8,y+i-128);       
  1740.                         p++;
  1741.                 }       
  1742.         }
  1743. /*        else if((y<192)&&(andwei>=192))
  1744.         {
  1745.                 LCD_CS1=0;
  1746.                 LCD_CS2=0;
  1747.                 for(i=0;i<12;i++)
  1748.                 {
  1749.                         write_xy_8bit(*p,x+12,i);
  1750.                         write_xy_8bit(*(p+12),x+20,i);       
  1751.                         p++;
  1752.                 }       
  1753.         }*/       
  1754. }
  1755. /////////////////////////////////////////////////////////////
  1756. //     函数名： display_str_gb2312
  1757. //     功能  ：显示文本,字符 (7x8)汉字(11x12)
  1758. //    一个汉字占用两个ASCII码
  1759. //    tiao shi cheng gong
  1760. /////////////////////////////////////////////////////////////
  1761. void display_str_gb2312(u8 *text,u8 x,u8 y)
  1762. {
  1763.         u8 i=0;
  1764.         u8 buffer1[26];
  1765.         u8 buffer2[10];
  1766.         u8 temp_y;
  1767.         u32 address;
  1768.         while(text[i]>0)
  1769.         {
  1770.                 if((text[i] >=(0xA1-0xa0)) && (text[i] <= (0Xa3-0xa0)) && (text[i+1] >=(0xA1-0xa0)))
  1771.                 {
  1772.                         temp_y=y+12;
  1773.                         if(temp_y>191)
  1774.                         {
  1775.                                 x+=12;
  1776.                                 y=0;
  1777.                         }
  1778.                         text[i] = text[i] + 0xa0 ;
  1779.                         address =(u32)(((text[i]-0xA1)*94 +(text[i+1] - 0xA1))*24+ 0x3cf80);
  1780.                         read_bytes_fromZIC(buffer1,address,24);
  1781.                         write_xy_11x12_ch(buffer1, x, y);
  1782.                         i+=2;
  1783.                         y+=12;
  1784.                 }
  1785.                 else if((text[i] == (0Xa9-0xa0)) && (text[i+1] >=(0xA1-0xa0)))
  1786.                 {
  1787.                         temp_y=y+12;
  1788.                         if(temp_y>191)
  1789.                         {
  1790.                                 x+=12;
  1791.                                 y=0;
  1792.                         }
  1793.                         text[i] = text[i] + 0xa0 ;
  1794.                         address =(u32)((282 + (text[i+1] - 0xA1))*24+ 0x3cf80);
  1795.                         read_bytes_fromZIC(buffer1,address,24);
  1796.                         write_xy_11x12_ch(buffer1, x, y);
  1797.                         i+=2;
  1798.                         y+=12;
  1799.                 }
  1800.                 else if((text[i] >=(0xB0-0xa0)) && (text[i] <= (0xF7-0xa0)) && (text[i+1] >=(0xA1-0xa0)))
  1801.                 {
  1802.                         temp_y=y+12;
  1803.                         if(temp_y>191)
  1804.                         {
  1805.                                 x+=12;
  1806.                                 y=0;
  1807.                         }
  1808.                         text[i] = text[i] + 0xa0 ;
  1809.                         address = (u32)(((text[i] - 0xB0) * 94 + (text[i+1] - 0xA1)+ 376)*24+ 0x3cf80);
  1810.                         read_bytes_fromZIC(buffer1,address,24);
  1811.                         write_xy_11x12_ch(buffer1, x, y);
  1812.                         i+=2;
  1813.                         y+=12;
  1814.                 }
  1815.                 else if ((text[i] >= 0x20) && (text[i] <= 0x7E))
  1816.                 {
  1817.                         temp_y=y+8;                       //判断剩余列数是否可以写完一个字符
  1818.                         if(temp_y>191)                    //如果剩余列数小于8
  1819.                         {
  1820.                                 x+=12;                           // 行地址增加一页，列地址为0
  1821.                                 y=0;
  1822.                         }
  1823.                         address=(u32)((text[i]-0x20)*8+0x66c0);  //取点阵地址
  1824.                         read_bytes_fromZIC(buffer2,address,8);   //取点阵数据，存储在 pbuffer
  1825.                         write_7x8_English(buffer2, x, y);      //xian shi
  1826.                         i+=1;                                 //字符地址加1，
  1827.                         y+=8;                                // 列数加8
  1828.                 }
  1829.                 else
  1830.                         break;
  1831.         }
  1832. }
  1833. ///////////////////////////////////////////////////////////////
  1834. //    函数名：display_str_15x16_ch
  1835. //    功能  ：显示15x16汉字串
  1836. //    调试成功
  1837. ///////////////////////////////////////////////////////////////
  1838. void display_str_15x16_ch(u8 *text,u8 x,u8 y)
  1839. {
  1840.         u8 i=0;
  1841.         u8 buffer[34];
  1842.         u8 temp_y;
  1843.         u32 address;
  1844.        
  1845.         while(text[i]>0)
  1846.         {

  1848.                 LCD_write_command(0xc0);
  1849.                 IWDG_Feed();
  1850.                
  1851.                 if((text[i] >=0xA4) && (text[i] <= 0Xa8) && (text[i+1] >=0xA1))
  1852.                 {
  1853.                         temp_y=y+16;
  1854.                         if(temp_y>192)
  1855.                         {
  1856.                                 x+=16;
  1857.                                 y=0;
  1858.                         }
  1859.                         address=0;
  1860.                         read_bytes_fromZIC(buffer,address,32);
  1861.                         write_xy_15x16_ch( buffer, x, y);
  1862.                         i+=2;
  1863.                         y+=16;
  1864.                 }
  1865.                 else if((text[i] >=0xA1) && (text[i] <= 0Xa9) && (text[i+1] >=0xA1))
  1866.                 {
  1867.                         temp_y=y+16;
  1868.                         if(temp_y>192)
  1869.                         {
  1870.                                 x+=16;
  1871.                                 y=0;
  1872.                         }
  1873.                         address =((text[i] - 0xA1) * 94 + (text[i+1] - 0xA1))*32;

  1875.                         read_bytes_fromZIC(buffer,address,32);
  1876.                         write_xy_15x16_ch( buffer, x, y);
  1877.                         i+=2;
  1878.                         y+=16;
  1879.                 }
  1880.                 else if((text[i] >=0xB0 )&& (text[i] <= 0xF7) && (text[i+1] >=0xA1))
  1881.                 {
  1882.                         temp_y=0;
  1883.                         temp_y=y+16;
  1884.                         if(temp_y>192)
  1885.                         {
  1886.                                 x+=16;
  1887.                                 y=0;
  1888.                         }
  1889.                         address = ((text[i] - 0xB0) * 94 + (text[i+1] - 0xA1)+ 846)*32;

  1891.                         read_bytes_fromZIC(buffer,address,32);
  1892.                         write_xy_15x16_ch( buffer, x, y);
  1893.                         i+=2;
  1894.                         y+=16;
  1895.                 }
  1896.                 else
  1897.                 {
  1898.                         break;
  1899.                 }
  1900.                
  1901.         }
  1902. }
  1903. ///////////////////////////////////////////////////////////////////////////
  1904. //           函数名 ：write_wherepage_8bit
  1905. //           功能   ：在一页的指定地址写1列数据
  1906. //
  1907. ///////////////////////////////////////////////////////////////////////////
  1908. void write_wherepage_8bit(u8 data,u8 page,u8 y)
  1909. {

  1911.         if(y<64)
  1912.         {
  1913.                 LCD_CS1 = 0;
  1914.                 LCD_CS2 = 0;
  1915.                 LCD_write_command(0xc0);
  1916.                 write_page_8bit(&data,page,y,1);
  1917.         }
  1918.         else if((y>=64)&&(y<128))
  1919.         {
  1920.                 LCD_CS1 = 0;
  1921.                 LCD_CS2 = 1;
  1922.                 LCD_write_command(0xc0);
  1923.                 write_page_8bit(&data,page,y-64,1);
  1924.         }
  1925.         else
  1926.         {
  1927.                 LCD_CS1 = 1;
  1928.                 LCD_CS2 = 0;
  1929.                 LCD_write_command(0xc0);
  1930.                 write_page_8bit(&data,page,y-128,1);
  1931.         }
  1932.        
  1933. }
  1934. ///////////////////////////////////////////////////////////////////////////
  1935. //           函数名 ：write_wherepage_nbit
  1936. //           功能   ：在一页的指定地址写n列数据  ,数据不超过一页
  1937. //
  1938. ///////////////////////////////////////////////////////////////////////////
  1939. void write_wherepage_nbit(u8 *ps,u8 page,u8 y,u8 len)
  1940. {
  1941.         u8 i;
  1942.         for(i=0;i<len;i++)
  1943.         {
  1944.                 write_wherepage_8bit(*ps,page,y+i) ;
  1945.                 ps++;
  1946.         }
  1947. }
  1948. ///////////////////////////////////////////////////////////////
  1949. //        函数名: write_string_dat
  1950. //        功能  ：在指定的地址写入n列数据串
  1951. //       write_xy_8bit(u8 datt,u8 x,u8 y)
  1952. //       write_page_8bit(u8 *buffer,u8 page,u8 y,u8 n)
  1953. ////////////////////////////////////////////////////////////////
  1954. void write_string_dat(u8 h_addr,u8 l_addr,u8 *ps,u16 len)
  1955. {
  1956.         u8 where_page,where_y;
  1957.         u8 remain_y;
  1958.         u16 Address;
  1959.         Address = (u16)(h_addr<<8);
  1960.         Address = Address + l_addr;
  1961.         where_page = Address/192 ;     //把总的地址变为 页地址 和 列地址
  1962.         where_y    = Address%192 ;
  1963.         remain_y   = 192 - where_y ;     //在起始页中剩余的列数
  1964.         if(len<=remain_y) remain_y = len ;   //如果要写入的数据长度小于起始页中剩余的列数，则把长度字节赋予列数字节
  1965.         while(1)
  1966.         {
  1967.                 write_wherepage_nbit(ps,where_page,where_y,remain_y) ;    //在指定的页指定的列写入remain_y个数据
  1968.                 if(len==remain_y) break;                                //如果 len 与 remain_y 相等，则退出循环
  1969.                 else     //len > remain_y
  1970.                 {
  1971.                         ps += remain_y ;                         //数组数据地址加remain_y
  1972.                         where_page += 1;                        //页地址加一
  1973.                         where_y = 0;                           //列地址归零
  1974.                        
  1975.                         len = len - remain_y;               //数据长度减去remain_y
  1976.                         if(len>=192)remain_y=192 ;          //如果剩余的数据长度大于192，则把192赋予remain_y
  1977.                         else remain_y = len ;               //否则，把len 赋予remain_y
  1978.                 }
  1979.         }
  1980. }


复制代码


LCD.rar

18.15 KB, 下载次数: 266, 下载积分: 黑币 -5

19264屏
作者: fsss007    时间: 2016-7-10 20:56
这个我收藏了，很有用哦
作者: w0can    时间: 2016-9-6 17:13
不错，借鉴一下
作者: jor    时间: 2016-10-29 13:11
楼主有联系qq号给我
作者: jor    时间: 2016-10-29 13:13
我的1023010634请你吃大餐加我
作者: eric9779    时间: 2016-12-8 15:18
很不错，收藏一下看看
作者: xiexiaoshuyan    时间: 2016-12-19 23:17
挺有用的，受益颇多
作者: sam851217    时间: 2017-2-6 22:40
这个我收藏了，很有用哦
作者: yifabin023    时间: 2017-2-8 00:43
收藏，有用
作者: wangweiguo2002    时间: 2017-4-4 21:38
这个我收藏了，很有用哦
作者: xinruan    时间: 2017-5-2 20:19
这个我收藏了,谢谢！
作者: lqb7733    时间: 2017-6-29 13:39
不错！！！！！！！！！！！！！！
作者: liyidage    时间: 2017-6-29 17:10
有项目要用，学习了
作者: 启发    时间: 2017-7-6 14:31
好&nbsp; &nbsp; 这个不错！！正需要呢
作者: wangweiguo2002    时间: 2017-9-16 10:12
很好的程序  谢谢啦
作者: Rongling    时间: 2017-10-17 13:22
正缺这个东西呢
作者: 120299797    时间: 2017-11-20 16:44
h文件跟c文件都下载
作者: 120299797    时间: 2017-11-29 16:11
非常感谢
作者: inmoment    时间: 2018-1-23 10:01
您好：我用这个程序没有显示啊好难受
作者: LIMBOS    时间: 2018-4-19 19:36
不错刚好在整理这方面资料
作者: jingcolin    时间: 2018-7-18 15:00
这个很有好，正好学习用，楼主给力啊
作者: jingcolin    时间: 2018-7-18 15:01
这个正合适新手学习使用，楼主给力啊
作者: xo37    时间: 2019-2-2 14:00
19264 都是3片选的，好像……
作者: zmr1992    时间: 2019-2-12 09:34
想下载····分不够······
作者: zp17777    时间: 2019-7-22 19:35
正好需要呢，感谢
作者: hilam    时间: 2019-9-5 23:12
楼主这个是啥屏吧，只有CS1/CS2。没有CS3,我的12964有CS3
作者: zp17777    时间: 2019-10-22 17:07
很不错，收藏下，感谢楼主
作者: 3119134879    时间: 2019-12-2 18:23
初学者表示反显是那一部分阿
作者: joyb    时间: 2023-10-28 00:53
Ks0108的19264屏，如何画圆？
作者: sdo7758    时间: 2023-10-29 11:48
真详细呀
作者: dnxbf    时间: 2023-11-1 11:05
好帖，学习中。



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1