单片机论坛

 找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 5489|回复: 23
打印 上一主题 下一主题
收起左侧

用STM32设计19264的屏程序 包括点、线、圆、矩形、反显、任意位置的读写、汉字字符...

  [复制链接]
跳转到指定楼层
楼主
包括点、线、圆、矩形、反显、任意位置的读写、汉字字符的写,内容丰富,很有用 ,在产品中已经应用

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

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

  15. GPIO_InitTypeDef  GPIO_InitStructure;

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

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

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

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

  80. u8 SPI_Receive_byte(void)
  81. {
  82.         u8 retry=0;
  83.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) != SET)       
  84.         {
  85.                 retry++;
  86.                 if(retry>200)return 0;
  87.         }
  88.         SPI_I2S_SendData(SPI2, 0x00);
  89.        
  90.         retry=0;
  91.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET)
  92.         {
  93.                 retry++;
  94.                 if(retry>200)return 0;
  95.         }
  96.         return SPI_I2S_ReceiveData(SPI2);        
  97. }


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


  139. /**************************************************
  140.                  LCD函数
  141. ****************************************************/
  142. void LCD_Init(void)         //LED IO初始化
  143. {       
  144. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC, ENABLE);         //使能PA端口时钟
  145.         ////////////////////////////////////////////////////////////////////
  146.         ///数据口初始化为推挽输出
  147. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|
  148.                                       GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7;                                 //LED0-->PA. 端口配置
  149. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  //推挽输出
  150. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  151. GPIO_Init(GPIOA, &GPIO_InitStructure);
  152.                                        
  153. //////////////////////////////////////////////////////////////////////
  154.        
  155. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;                             //LCD-->PC.10  背光控制
  156. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  //推挽输出
  157. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  158. GPIO_Init(GPIOC, &GPIO_InitStructure);
  159.        
  160. GPIO_SetBits(GPIOC,GPIO_Pin_10);                                                  //PD.2 输出高
  161.         /////////////////////////////////////////////////

  162.        
  163. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9;                             //LCD控制口
  164. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  //推挽输出
  165. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  166. GPIO_Init(GPIOB, &GPIO_InitStructure);       

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

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

  219. //        while(kk==0x80) ;
  220.         GPIOA->CRL = 0x33333333;
  221.        
  222. /*        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|
  223.                                       GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7;;
  224.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;    //推挽输出
  225.         GPIO_Init(GPIOA, &GPIO_InitStructure);*/
  226.        
  227. }
  228. /////////////////////////////////////////写命令
  229. void LCD_write_command(u8 command)
  230. {
  231.         checkbusy();
  232.         LCD_RW=0;
  233.         LCD_RS=0;
  234.         delay_us(1);
  235. //        GPIOA->ODR = GPIOA->ODR&0xff00;
  236.         GPIOA->ODR =  command;
  237.        
  238.         LCD_E=1;
  239.         delay_us(3);
  240.         LCD_E=0;

  241. }
  242. ////////////////////////////////////////写数据
  243. void LCD_write_data(u8 datt)
  244. {
  245.         checkbusy();
  246.         LCD_RW=0;
  247.         LCD_RS=1;
  248.         delay_us(1);
  249. //        GPIOA->ODR = GPIOA->ODR&0xff00 ;
  250.         GPIOA->ODR = datt;

  251.         LCD_E=1;
  252.         delay_us(3);
  253.         LCD_E=0;
  254. }
  255. //////////////////////////////////////读数据
  256. u8 LCD_read_data(void)
  257. {
  258.         u8 aa;
  259. /*        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|
  260.                                       GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7;                                 //LED0-->PA.8 端口配置
  261.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;                  //上拉输入
  262.   GPIO_Init(GPIOA, &GPIO_InitStructure);*/
  263.         delay_us(6);
  264.         GPIOA->CRL = 0x88888888;                       //初始化为上拉输入 PA0-7
  265.         GPIOA->BSRR=0X00FF;                             //假读一次
  266.         LCD_RW=1;
  267.         LCD_RS=1;
  268.         LCD_E=1;
  269.         LCD_E=0;
  270.        
  271.         GPIOA->BSRR=0X00FF;
  272.         LCD_RW=1;
  273.         LCD_RS=1;
  274.         LCD_E=1;
  275.         delay_us(3);                        //
  276.         aa=(u8)(GPIOA->IDR&0xff);
  277.         delay_us(2);
  278.         LCD_E=0;
  279.        
  280. /*        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|
  281.                                       GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7;                                 //LED0-->PA.8 端口配置
  282.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  //推挽输出
  283.   GPIO_Init(GPIOA, &GPIO_InitStructure);*/
  284.         GPIOA->CRL = 0x33333333;        //////推挽输出
  285.         GPIOA->BSRR=0X00FF;
  286.         return aa;
  287. }
  288. ///////////////////////////////////////////////连续读
  289. //                                   函数名:LCD_read_n_dat()
  290. //                                        功能  :在指定的位置读取n列数据
  291. //
  292. //
  293. ///////////////////////////////////////////////
  294. void LCD_read_n_dat(u8 *buffer,u8 page,u8 y,u8 n)
  295. {
  296.         u8 i;
  297.        
  298.         LCD_write_command(BEGIN_PAGE+page);
  299.         LCD_write_command(BEGIN_Y+y);
  300.         delay_us(6);
  301.         GPIOA->CRL = 0x88888888;                             //初始化为上拉输入 PA0-7

  302.         GPIOA->BSRR=0X00FF;
  303.         LCD_RW=1;
  304.         LCD_RS=1;
  305.         LCD_E=1;
  306. //        delay_us(1);
  307.         LCD_E=0;
  308.        
  309.         GPIOA->BSRR=0X00FF;
  310.         LCD_RW=1;
  311.         LCD_RS=1;

  312.         for(i=0;i<n;i++)
  313.         {
  314.                 LCD_E=1;
  315.                 delay_us(3);
  316.                 buffer[i] =~((u8)(GPIOA->IDR&0x00ff));
  317. //                buffer[i] = ~buffer[i];
  318.                 delay_us(2);
  319.                 LCD_E=0;
  320.                 delay_us(3);
  321.         }
  322.         GPIOA->CRL = 0x33333333;        //////推挽输出
  323.         GPIOA->BSRR=0X00FF;

  324. }

  325. void LCD_read_zheng_dat(u8 *buffer,u8 page,u8 y,u8 n)
  326. {
  327.         u8 i;

  328.         LCD_write_command(BEGIN_PAGE+page);
  329.         LCD_write_command(BEGIN_Y+y);
  330.         delay_us(6);
  331.         GPIOA->CRL = 0x88888888;                             //初始化为上拉输入 PA0-7

  332.         GPIOA->BSRR=0X00FF;
  333.         LCD_RW=1;
  334.         LCD_RS=1;
  335.         LCD_E=1;
  336.         LCD_E=0;
  337.        
  338.         GPIOA->BSRR=0X00FF;
  339.         LCD_RW=1;
  340.         LCD_RS=1;

  341.         for(i=0;i<n;i++)
  342.         {
  343.                 LCD_E=1;
  344.                 delay_us(3);
  345.                 buffer[i] =(u8)(GPIOA->IDR&0x00ff);
  346.                 delay_us(2);
  347.                 LCD_E=0;
  348.                 delay_us(3);
  349.         }
  350.         GPIOA->CRL = 0x33333333;        //////推挽输出
  351.         GPIOA->BSRR=0X00FF;
  352. }
  353. ///////////////////////////////////////////////////////////
  354. //    函数名 :display_onepage_reverse_cor
  355. //    功能   :在指定的页反色显示
  356. //
  357. //
  358. ///////////////////////////////////////////////////////////
  359. void display_onepage_reverse_cor(u8 onepage,u8 y1,u8 len)
  360. {
  361.         u8 y2;
  362.         u8 andy;
  363.         u8 oddy;
  364.         u8 strdata[190];
  365.         y2 =y1+len-1;
  366.         if((y1<64)&&(y2<64))
  367.                 {
  368.                         LCD_CS1 =0;
  369.                         LCD_CS2 =0;
  370.                         LCD_read_n_dat(strdata,onepage,y1,len);
  371.                         write_page_8bit(strdata,onepage,y1, len);

  372.                 }
  373.                 else if((y1<64)&&(y2>=64)&&(y2<128))
  374.                 {
  375.                         oddy =64-y1;
  376.                         andy =len-oddy;
  377.                         LCD_CS1 =0;
  378.                         LCD_CS2 =0;
  379.                         LCD_read_n_dat(strdata,onepage,y1,oddy);
  380.                         write_page_8bit(strdata,onepage,y1, oddy);
  381.        
  382.                        
  383.                         LCD_CS1 =0;
  384.                         LCD_CS2 =1;
  385.                         LCD_read_n_dat(strdata,onepage,0,andy);
  386.                         write_page_8bit(strdata,onepage,0, andy);
  387.                        
  388.                 }
  389.                 else if((y1<64)&&(y2>=128))      //1、2、3屏中
  390.                 {
  391.                         oddy =64-y1;
  392.                         andy =y2-127;
  393.                 //        andy = len-64-oddy;
  394.                         LCD_CS1 =0;
  395.                         LCD_CS2 =0;
  396.                         LCD_read_n_dat(strdata,onepage,y1,oddy);
  397.                         write_page_8bit(strdata,onepage,y1, oddy);
  398.                        
  399.                         LCD_CS1 =0;
  400.                         LCD_CS2 =1;
  401.                         LCD_read_n_dat(strdata,onepage,0,64);
  402.                         write_page_8bit(strdata,onepage,0, 64);
  403.                        
  404.                         LCD_CS1 =1;
  405.                         LCD_CS2 =0;
  406.                         LCD_read_n_dat(strdata,onepage,0,andy);
  407.                         write_page_8bit(strdata,onepage,0, andy);
  408.                        
  409.                 }
  410.                 else if((y1>63)&&(y1<128)&&(y2<128))
  411.                 {
  412.                         LCD_CS1 =0;
  413.                         LCD_CS2 =1;
  414.                         LCD_read_n_dat(strdata,onepage,y1-64,len);
  415.                         write_page_8bit(strdata,onepage,y1-64, len);
  416.                 }
  417.                 else if((y1>63)&&(y1<128)&&(y2>=128))
  418.                 {
  419.                         oddy =128-y1;
  420.                         andy =len-oddy;
  421.                         LCD_CS1 =0;
  422.                         LCD_CS2 =1;
  423.                         LCD_read_n_dat(strdata,onepage,y1-64,oddy);
  424.                         write_page_8bit(strdata,onepage,y1-64, oddy);
  425.                        
  426.                         LCD_CS1 =1;
  427.                         LCD_CS2 =0;
  428.                        
  429.                         LCD_read_n_dat(strdata,onepage,0,andy);
  430.                         write_page_8bit(strdata,onepage,0, andy);
  431.                        
  432.                 }
  433.                 else
  434.                 {
  435.                         LCD_CS1 =1;
  436.                         LCD_CS2 =0;
  437.                         LCD_read_n_dat(strdata,onepage,y1-128,len);
  438.                         write_page_8bit(strdata,onepage,y1-128, len);               
  439.                 }
  440. }
  441. ///////////////////////////////////////////////////
  442. //      函数名 :Set_byte_reverse()
  443. //      功能   :单字节取反
  444. /////////////////////////////////////////////////
  445. u8 Set_low_byte_reverse(u8 datt,u8 len)    //从低位开始取反
  446. {
  447.         static u8 aa;
  448.         u8 i;
  449.         aa =datt;
  450.         for(i=0;i<len;i++)
  451.         {
  452.                 if(datt&0x01)aa &= (u8)(~(1<<i));       //取反
  453.                 else aa |= (u8)(1<<i);
  454.                 datt=datt>>1;
  455.         }
  456.         return aa;
  457. }

  458. u8 Set_high_byte_reverse(u8 datt,u8 len)     //从高位开始取反
  459. {
  460.         static u8 aa;
  461.         u8 i;
  462.         aa =datt;
  463.         for(i=0;i<len;i++)
  464.         {
  465.                 if(datt&0x80)aa &= (u8)(~(1<<(7-i)));
  466.                 else aa |= (u8)(1<<(7-i));
  467.                 datt=datt<<1;
  468.         }
  469.         return aa;
  470. }
  471. ////////////////////////////////////////////////////////////////////
  472. //        函数名:display_lossonepage_revcor
  473. //        功能  :不足一页的反显
  474. //        corflag表示一页中向上取还是向下取值 0:上  1:下
  475. ////////////////////////////////////////////////////////////////////
  476. void display_lossonepage_revcor(u8 onepage,u8 onerow,u8 y1,u8 ylen,u8 corflag)
  477. {
  478.         u8 i;
  479.         u8 y2;
  480.         u8 oddy,andy;
  481.         u8 strdata[70];
  482.         u8 strdata1[70];
  483.         u8 strdata2[70];
  484.         y2 =y1+ylen-1;
  485.         if((y1<64)&&(y2<64))                ///////第一屏
  486.                 {
  487.                         LCD_CS1 =0;
  488.                         LCD_CS2 =0;
  489.                         IWDG_Feed();
  490.                         LCD_read_zheng_dat(strdata,onepage, y1,ylen);
  491.                         if(corflag==0)
  492.                         {
  493.                                 for(i=0;i<ylen;i++)
  494.                                 {
  495.                                         strdata[i] =Set_high_byte_reverse(strdata[i], onerow);
  496.                                 }
  497.                         }
  498.                         else
  499.                         {
  500.                                 for(i=0;i<ylen;i++)
  501.                                 {
  502.                                         strdata[i] =Set_low_byte_reverse(strdata[i], onerow);
  503.                                 }
  504.                         }
  505.                         IWDG_Feed();
  506.                         write_page_8bit(strdata,onepage,y1, ylen);
  507.                 }
  508.                 else if((y1<64)&&(y2>=64)&&(y2<128))        /////第一 屏和第二屏
  509.                 {
  510.                         oddy =64-y1;             //di yi ping
  511.                         andy =ylen-oddy;
  512.                         LCD_CS1 =0;
  513.                         LCD_CS2 =0;
  514.                         IWDG_Feed();
  515.                         LCD_read_zheng_dat(strdata,onepage, y1,oddy);
  516.                         if(corflag==0)
  517.                         {
  518.                                 for(i=0;i<oddy;i++)
  519.                                 {
  520.                                         strdata[i] =Set_high_byte_reverse(strdata[i], onerow);
  521.                                 }
  522.                         }
  523.                         else
  524.                         {
  525.                                 for(i=0;i<oddy;i++)
  526.                                 {
  527.                                         strdata[i] =Set_low_byte_reverse(strdata[i], onerow);
  528.                                 }
  529.                         }
  530.                         write_page_8bit(strdata,onepage,y1, oddy);

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

  712.         u8 i;
  713.         int xlen;       // x长度
  714.         int ylen;       //y 长度
  715.         u8 temp;
  716.         u8 wholepage1;   // 是否是处在整页的开始
  717.         u8 wholepage2;
  718.         u8 wholepage;
  719.         u8 remainrow1;   
  720. //        u8 remainrow2;
  721.         u8 whererow1;
  722.         u8 whererow2;
  723.         u8 temppage;

  724.        
  725.         if(y1>y2)
  726.         {
  727.                 temp =y1;
  728.                 y1 =y2;
  729.                 y2 =temp;
  730.         }
  731.         if(x1>x2)
  732.         {
  733.                 temp =x1;
  734.                 x1 =x2;
  735.                 x2 =temp;
  736.         }


  737.         xlen = x2-x1+1;
  738.         ylen = (y2-y1)+1;
  739.         wholepage1 =x1/8;       //
  740.         wholepage2 =x2/8;   //
  741.         whererow1 =x1%8;           //是否是整页的起始
  742.         whererow2 =(x2+1)%8;

  743.         if(xlen==8)               // 如果是一个字节
  744.         {
  745.                 if(whererow1==0)              //如果是整页
  746.                 {
  747.                         IWDG_Feed();
  748.                         display_onepage_reverse_cor(wholepage1,y1, ylen);
  749.                 }
  750.                 else                     //如果不是
  751.                 {
  752.                         IWDG_Feed();
  753.                         remainrow1 = 8-whererow1;
  754.                         display_lossonepage_revcor( wholepage1, remainrow1,y1, ylen, 0);
  755.                         display_lossonepage_revcor( wholepage2, whererow2, y1,ylen, 1);
  756.                 }
  757.         }                        //多余一个字节
  758.         else if(xlen>8)        
  759.         {
  760.                

  761.                 if((whererow1==0)&&(whererow2==0))
  762.                 {
  763.                         wholepage = xlen/8;
  764.                         for(i=0;i<wholepage;i++)
  765.                         {
  766.                                 display_onepage_reverse_cor(wholepage1+i,y1, ylen);
  767.                         }
  768.                 }
  769.                 else
  770.                 {
  771.                         remainrow1 = 8-whererow1;        ////首页行数    末页行数是whererow2
  772.                 //        remainrow2 = 8-whererow2;
  773.                         temppage = xlen-(remainrow1+whererow2);   //判断有几个整页
  774.                         if(temppage>=8)
  775.                         wholepage = temppage/8;
  776.                         else wholepage=0;
  777.                         IWDG_Feed();
  778.                         display_lossonepage_revcor( wholepage1, remainrow1,y1, ylen, 0);   //上半部分
  779.                        
  780.                         for(i=0;i<wholepage;i++)                          //中间整页部分
  781.                         {
  782.                                 display_onepage_reverse_cor(wholepage1+1+i,y1, ylen);
  783.                         }
  784.                         IWDG_Feed();
  785.                         display_lossonepage_revcor( wholepage2, whererow2, y1,ylen, 1);   //下半部分

  786.                         ///////////////////////////////////////////////////////////////
  787.                 }

  788.         }

  789. }
  790. ////////////////////////////////////////清屏
  791. //
  792. // write_wherepage_8bit(u8 data,u8 page,u8 y)
  793. /////////////////////////////////////////
  794. void LCD_clear(void)
  795. {
  796.         u16 count;
  797.         u8 page,temp=1,num;

  798.         LCD_CS1=LCD_CS2=0;
  799.         for(num=0;num<3;num++)
  800.         {       
  801. //                LCD_write_command(0xc0);             ////////////行显示
  802.                 for(page=0xb8;page<0xc0;page++)
  803.                 {
  804.                         LCD_write_command(0xc0);
  805.                         LCD_write_command(page);
  806.                         for(count=64;count>0;count--)
  807.                         {
  808.                                 LCD_write_data(0x00);
  809.                         }
  810.                 }
  811.                 LCD_CS1=LCD_CS2;
  812.                 LCD_CS2=temp;
  813.                 temp=LCD_CS1;
  814.        
  815.         }
  816. }
  817. ///////////////////////////////////////////////////////
  818. //    在一屏内指定的页指定的列写n列数据
  819. //函数名: write_page_8bit
  820. ///////////////////////////////////////////////////////
  821. void write_page_8bit(u8 *buffer,u8 page,u8 y,u8 n)
  822. {
  823.         u8 i;
  824.         LCD_write_command(BEGIN_PAGE+page);
  825.         LCD_write_command(BEGIN_Y+y);
  826.         for(i=0;i<n;i++)
  827.         {
  828.                 LCD_write_data(*buffer);
  829.                 buffer++;
  830.         }
  831. }


  832. ////////////////////////////////////////////////////////
  833. // 函数名:write_xy_piont
  834. // 功能: 在指定的行和列 画一个点或者删除一个点
  835. // flag:  0  删除一个点 ,1  画一个点
  836. // CS1 CS2 :00     ,01    ,10  
  837. ////////////////////////////////////////////////////////
  838. void write_xy_point(u8 x,u8 y,u8 flag)
  839. {
  840.   u8 oddwei;
  841.         u8 wholepage;
  842.         u8 rowdata;
  843.         rowdata=0;
  844.         wholepage=x/8;             //行所在的页数
  845.         oddwei=x%8;                //所在页数的第几页
  846.         if(y<64)
  847.         {
  848.                 LCD_CS1=0;
  849.                 LCD_CS2=0;
  850.                 LCD_write_command(BEGIN_PAGE+wholepage);
  851.                 LCD_write_command(BEGIN_Y+y);
  852. //                checkbusy();
  853.                 rowdata= LCD_read_data();
  854.                 if(flag==1)
  855.                 rowdata |= 1<<oddwei;
  856.                 else
  857.                 rowdata &=~(1<<oddwei);
  858.                 write_page_8bit(&rowdata,wholepage,y,1);
  859. //                LCD_write_data(rowdata);
  860.                
  861.         }
  862.         else if((y>=64)&&(y<128))
  863.         {
  864.                 LCD_CS1=0;
  865.                 LCD_CS2=1;
  866.                 LCD_write_command(BEGIN_PAGE+wholepage);
  867.                 LCD_write_command(BEGIN_Y+y-64);
  868. //                checkbusy();
  869.                 rowdata= LCD_read_data();
  870.                 if(flag==1)
  871.                 rowdata |= 1<<oddwei;
  872.                 else
  873.                 rowdata &=~(1<<oddwei);
  874.                 write_page_8bit(&rowdata,wholepage,y-64,1);
  875. //                LCD_write_data(rowdata);
  876.                
  877.         }
  878.         else
  879.         {
  880.                 LCD_CS1=1;
  881.                 LCD_CS2=0;
  882.                 LCD_write_command(BEGIN_PAGE+wholepage);
  883.                 LCD_write_command(BEGIN_Y+y-128);
  884. //                checkbusy();
  885.                 rowdata= LCD_read_data();
  886.                 if(flag==1)
  887.                 rowdata |= 1<<oddwei;
  888.                 else
  889.                 rowdata &=~(1<<oddwei);
  890.                 write_page_8bit(&rowdata,wholepage,y-128,1);
  891. //                LCD_write_data(rowdata);

  892.         }
  893. }
  894. /////////////////////////////////////////////////////////////////
  895. //       画圆
  896. //
  897. //
  898. ///////////////////////////////////////////////////////////////
  899. void draw_circle(u8 x0,u8 y0,u8 r,u8 flagg)
  900. {
  901.         int a,b;
  902.         int di;
  903.         a=0;b=r;          
  904.         di=3-(r<<1);             //
  905.         while(a<=b)
  906.         {
  907.                 write_xy_point(x0-b,y0-a,flagg);             //3           
  908.                 write_xy_point(x0+b,y0-a,flagg);             //0           
  909.                 write_xy_point(x0-a,y0+b,flagg);             //1      
  910.                 write_xy_point(x0-b,y0-a,flagg);             //7           
  911.                 write_xy_point(x0-a,y0-b,flagg);             //2            
  912.                 write_xy_point(x0+b,y0+a,flagg);             //4               
  913.                 write_xy_point(x0+a,y0-b,flagg);             //5
  914.                 write_xy_point(x0+a,y0+b,flagg);             //6
  915.                 write_xy_point(x0-b,y0+a,flagg);            
  916.                 a++;
  917.                 //Bresenham   
  918.                 if(di<0)di +=4*a+6;          
  919.                 else
  920.                 {
  921.                         di+=10+4*(a-b);   
  922.                         b--;
  923.                 }
  924.                 write_xy_point(x0+a,y0+b,flagg);
  925.         }
  926. }
  927. ////////////////////////////////////////////////////////////////
  928. //  函数名:  draw_line
  929. //  功能  :  在任意两点间画一条直线或者删除一条直线
  930. //Bresenham算法-直线光栅法算法  flag : 0  删除,1 画一条直线
  931. ////////////////////////////////////////////////////////////////
  932. void draw_line(u8 x0,u8 y0,u8 x1,u8 y1,u8 flag)
  933. {
  934.         u16 t;
  935.         int nowrow,nowcol;   //   行 列
  936.         int incx,incy;    //   基准
  937.         int distance_x,distance_y,distance;   
  938.         int xerr=0,yerr=0;
  939.        
  940.         nowrow=x0;   
  941.         nowcol=y0;
  942.         distance_x=(int)x1-(int)x0+1;
  943.         distance_y=(int)y1-(int)y0+1;
  944.         if(distance_x>0)incx=1;   //  判断x1 yu x0 大小,然后给基准x赋值
  945.         else if(distance_x==0)incx=0;
  946.         else
  947.         {
  948.                 incx=-1;
  949.                 distance_x=(-distance_x)+2;
  950.         }
  951.         if(distance_y>0)incy=1;  //判断y1 与 y0 大小,然后给基准x赋值
  952.         else if(distance_y==0)incy=0;
  953.         else
  954.         {
  955.                 incy=-1;
  956.                 distance_y=(-distance_y)+2;
  957.         }
  958.         if(distance_x>distance_y)distance=distance_x;
  959.         else distance=distance_y;
  960.         for(t=0;t<distance+1;t++)
  961.         {
  962.                 write_xy_point(nowrow,nowcol,flag);
  963.                 xerr+=distance_x;
  964.                 yerr+=distance_y;
  965.                 if(xerr>distance)
  966.                 {
  967.                         xerr-=distance;
  968.                         nowrow+=incx;       
  969.                 }
  970.                 if(yerr>distance)
  971.                 {
  972.                         yerr-=distance;
  973.                         nowcol+=incy;       
  974.                 }
  975.         }       
  976. }
  977. //////////////////////////////////////////////////////
  978. //   函数名: draw_dect
  979. //   功能  : 画一个矩形(x1,y1)(x2,y2)或者删除一个矩形
  980. ////////////////////////////////////////////////////////
  981. void draw_dect(u8 x1,u8 y1,u8 x2,u8 y2,u8 flag)
  982. {
  983.         draw_line(x1,y1,x1,y2,flag);
  984.         draw_line(x1,y2,x2,y2,flag);
  985.         draw_line(x2,y1,x2,y2,flag);
  986.         draw_line(x1,y1,x2,y1,flag);
  987. }
  988. /////////////////////////////////////////////////////
  989. //   函数名:fill_rect
  990. //   功能  :填充指定的矩形区域
  991. ////////////////////////////////////////////////////
  992. void fill_rect(u8 x0,u8 y0,u8 x1,u8 y1,u8 flag)
  993. {
  994.         u8 i;
  995.         u8 distance_x;
  996.         if(x0>x1)
  997.         {
  998.                 distance_x=x0-x1;
  999.                 for(i=0;i<=distance_x;i++)       
  1000.                 {
  1001.                         draw_line(x1+i,y0,x1+i,y1,flag);       
  1002.                 }
  1003.         }
  1004.         else
  1005.         {
  1006.                 distance_x=x1-x0;
  1007.                 for(i=0;i<=distance_x;i++)       
  1008.                 {
  1009.                         draw_line(x0+i,y0,x0+i,y1,flag);       
  1010.                 }
  1011.         }       
  1012. }
  1013. ////////////////////////////////////////////////////////
  1014. //   函数名: write_xy_8bit
  1015. //   功能  :在任意的x,y点写一列数据
  1016. //   为在任意的位置写字符和汉字做准备
  1017. ////////////////////////////////////////////////////////
  1018. void write_xy_8bit(u8 datt,u8 x,u8 y)
  1019. {
  1020.         static u8 tempdat;
  1021.         static u8 read_datt;
  1022.         u8 wholepage,frontpage_wei,nextpage_wei,whererow;
  1023.         read_datt=0;
  1024.         tempdat=datt;
  1025.         wholepage=x/8;                                 ////// 行所在的当前页
  1026.         whererow=x%8;                                                                 /////// x所在页的第几行
  1027.         frontpage_wei=8-whererow;                      /////// 当前页需要用到几行
  1028.         nextpage_wei=8-frontpage_wei;                //////下一页需要用到几行
  1029.         LCD_write_command(BEGIN_PAGE+wholepage);         /////读当前页数据前先写入地址
  1030.         LCD_write_command(BEGIN_Y+y);
  1031.         read_datt= LCD_read_data();                  ////// 读取当前页数据
  1032.         read_datt&=0xff>>frontpage_wei;
  1033.         tempdat=tempdat<<whererow;
  1034.         tempdat|= read_datt;
  1035.         write_page_8bit(&tempdat,wholepage,y,1);
  1036.         tempdat=0;
  1037.         read_datt=0;
  1038.         tempdat=datt;
  1039.         LCD_write_command(BEGIN_PAGE+wholepage+1);         /////读取下一页数据
  1040.         LCD_write_command(BEGIN_Y+y);
  1041.         read_datt= LCD_read_data();                  ////// 读取数据
  1042.         read_datt &= 0xff<<nextpage_wei;
  1043.         tempdat=tempdat>>frontpage_wei;
  1044.         tempdat |=read_datt;
  1045.         write_page_8bit(&tempdat,wholepage+1,y,1);       
  1046. }
  1047. ///////////////////////////////////////////////////////////////
  1048. //       函数名: write_xy_nbit
  1049. //                         功  能 :在任意的位置写 N 列数据
  1050. //   LCD_read_zheng_dat(u8 *buffer,u8 page,u8 y,u8 n)
  1051. //////////////////////////////////////////////////////////////
  1052. void write_xy_n8bit(u8 *pbuff,u8 x,u8 y,u8 len)
  1053. {
  1054.         static u8 i;
  1055.         u8 tempdat[35];
  1056.         u8 read_datt[35];
  1057.         u8 wholepage,frontpage_wei,nextpage_wei,whererow;

  1058.         wholepage=x/8;                                 ////// 行所在的当前页
  1059.         whererow=x%8;                                                                 /////// x所在页的第几行
  1060.         frontpage_wei=8-whererow;                      /////// 当前页需要用到几行
  1061.         nextpage_wei=8-frontpage_wei;                //////下一页需要用到几行
  1062.         
  1063. /*        for(i=0;i<35;i++)
  1064.         {
  1065.                 read_datt[i]=0;
  1066.                 tempdat[i]=0;
  1067.         }*/
  1068.         for(i=0;i<len;i++)
  1069.         tempdat[i]=pbuff[i];
  1070.         LCD_read_zheng_dat(read_datt,wholepage,y,len);
  1071.         for(i=0;i<len;i++)
  1072.         {
  1073.                 read_datt[i]&=0xff>>frontpage_wei;
  1074.                 tempdat[i]=tempdat[i]<<whererow;
  1075.                 tempdat[i]|= read_datt[i];
  1076.         }
  1077. //        LCD_write_command(BEGIN_ROW);
  1078.         write_page_8bit(tempdat,wholepage,y,len);

  1079. /*        for(i=0;i<len;i++)
  1080.         {
  1081.                 read_datt[i]=0;
  1082.                 tempdat[i]=0;
  1083.         }*/
  1084.         for(i=0;i<len;i++)
  1085.         {
  1086.                 tempdat[i]=pbuff[i];

  1087.         }
  1088.         LCD_read_zheng_dat(read_datt,wholepage+1,y,len);

  1089.         for(i=0;i<len;i++)
  1090.         {
  1091.                 read_datt[i]&=0xff<<nextpage_wei;
  1092.                 tempdat[i]=tempdat[i]>>frontpage_wei;
  1093.                 tempdat[i]|= read_datt[i];
  1094.         }
  1095. //        LCD_write_command(BEGIN_ROW);
  1096.         write_page_8bit(tempdat,wholepage+1,y,len);       
  1097. }
  1098. ///////////////////////////////////////////////////////////////
  1099. //   函数名:write_angwhere_English
  1100. //   功能  :在任意的(x,y) 的位置处写一个字符
  1101. //  一个字符占16个字节,上下8个字节(8*16)
  1102. ////////////////////////////////////////////////////////////////
  1103. void write_8x16_English(u8 *pps,u8 x,u8 y)  
  1104. {
  1105.         u8 i;
  1106.         u8 andwei;            // y行加上8个字节后新的行数                  
  1107.         u8 oddwei;           
  1108.         u8 oddwei1;            
  1109.         u8 tempwei;         
  1110.         u8 tempwei1;
  1111.         andwei=y+7;

  1112.         if(andwei<64)            //位于第一屏
  1113.         {
  1114.                 LCD_CS1=0;
  1115.                 LCD_CS2=0;
  1116.                 for(i=0;i<8;i++)
  1117.                 {
  1118.                         write_xy_8bit(*pps,x,y+i);
  1119.                         write_xy_8bit(*(pps+8),x+8,y+i);
  1120.                         pps++;
  1121.                 }
  1122.        
  1123.         }
  1124.         else if((y<64)&&(andwei>=64))    //位于第一屏和第二屏之间
  1125.         {
  1126.                 oddwei=andwei-63;           //  位于第2屏的位数
  1127.                 tempwei=8-oddwei;           //  位于第1屏的位数
  1128.                 LCD_CS1=0;
  1129.                 LCD_CS2=0;
  1130.                 for(i=0;i<tempwei;i++)      //位于第1屏
  1131.                 {
  1132.                         write_xy_8bit(*pps,x,y+i);
  1133.                         write_xy_8bit(*(pps+8),x+8,y+i);
  1134.                         pps++;
  1135.                 }
  1136.        
  1137.                 LCD_CS1=0;
  1138.                 LCD_CS2=1;
  1139.                 for(i=0;i<oddwei;i++)     //位于第2屏
  1140.                 {
  1141.                         write_xy_8bit(*(pps),x,i);
  1142.                         write_xy_8bit(*(pps+8),x+8,i);
  1143.                         pps++;
  1144.                 }
  1145.        
  1146.         }
  1147.         else if((y>=64)&&(andwei<128))     //位于第二屏中
  1148.         {
  1149.                 LCD_CS1=0;
  1150.                 LCD_CS2=1;
  1151.                 for(i=0;i<8;i++)
  1152.                 {
  1153.                         write_xy_8bit(*pps,x,y+i-64);
  1154.                         write_xy_8bit(*(pps+8),x+8,y+i-64);
  1155.                         pps++;
  1156.                 }
  1157.         }
  1158.         else if((y>63)&&(y<128)&&(andwei>=128))    //位于第2屏和第3屏之间
  1159.         {
  1160.                 oddwei1=andwei-127;          //位于第3屏的位数
  1161.                 tempwei1=8-oddwei1;           //位于第2屏
  1162.                 LCD_CS1=0;
  1163.                 LCD_CS2=1;
  1164.                 for(i=0;i<tempwei1;i++)       //位于第2屏
  1165.                 {
  1166.                         write_xy_8bit(*pps,x,y+i-64);
  1167.                         write_xy_8bit(*(pps+8),x+8,y+i-64);
  1168.                         pps++;
  1169.                 }
  1170.                 LCD_CS1=1;
  1171.                 LCD_CS2=0;
  1172.                 for(i=0;i<oddwei1;i++)        //位于第3屏
  1173.                 {
  1174.                         write_xy_8bit(*pps,x,i);
  1175.                         write_xy_8bit(*(pps+8),x+8,i);
  1176.                         pps++;
  1177.                 }
  1178.         }
  1179.         else if((y>=128)&&(andwei<192))   //位于第3屏
  1180.         {
  1181.                 LCD_CS1=1;
  1182.                 LCD_CS2=0;
  1183.                 for(i=0;i<8;i++)
  1184.                 {
  1185.                         write_xy_8bit(*pps,x,y+i-128);
  1186.                         write_xy_8bit(*(pps+8),x+8,y+i-128);
  1187.                         pps++;
  1188.                 }
  1189.                
  1190.         }       
  1191.         else if((y<192)&&(andwei>=192))
  1192.         {
  1193.                 LCD_CS1=0;
  1194.                 LCD_CS2=0;
  1195.                 for(i=0;i<8;i++)
  1196.                 {
  1197.                         write_xy_8bit(*pps,x+16,i);
  1198.                         write_xy_8bit(*(pps+8),x+24,i);
  1199.                         pps++;
  1200.                 }
  1201.         }
  1202. }
  1203. ////////////////////////////////////////////////////////////
  1204. //     函数名:write_7x8_English
  1205. //     共能  :在任意的位置显示一个字符(大小为7x8)
  1206. //     共占用8个字节
  1207. //     write_page_8bit(u8 *buffer,u8 page,u8 y,u8 n)
  1208. ////////////////////////////////////////////////////////////
  1209. void write_7x8_English(u8 *pps,u8 x,u8 y)
  1210. {
  1211.         u8 andwei;            // y行加上8个字节后新的行数                  
  1212.         u8 oddwei;                     
  1213.         u8 tempwei;         
  1214.         u8 oddpage;
  1215.         u8 wholepage;
  1216.        
  1217.         oddpage = x%8;
  1218.         wholepage = x/8;
  1219.         andwei=y+7;

  1220.         if(oddpage==0)
  1221.         {
  1222.                 if(andwei<64)            //位于第一屏
  1223.                 {
  1224.                         LCD_CS1=0;
  1225.                         LCD_CS2=0;
  1226.                         write_page_8bit(pps,wholepage,y,8);

  1227.                
  1228.                 }
  1229.                 else if((y<64)&&(andwei>=64))    //位于第一屏和第二屏之间
  1230.                 {
  1231.                         oddwei=andwei-63;           //  位于第2屏的位数
  1232.                         tempwei=8-oddwei;           //  位于第1屏的位数
  1233.                         LCD_CS1=0;
  1234.                         LCD_CS2=0;
  1235.                         write_page_8bit(pps,wholepage,y,tempwei);

  1236.                         LCD_CS1=0;
  1237.                         LCD_CS2=1;
  1238.                         write_page_8bit(pps+tempwei,wholepage,0,oddwei);

  1239.                 }
  1240.                 else if((y>=64)&&(andwei<128))     //位于第二屏中
  1241.                 {
  1242.                         LCD_CS1=0;
  1243.                         LCD_CS2=1;
  1244.                         write_page_8bit(pps,wholepage,y-64,8);

  1245.                 }
  1246.                 else if((y<128)&&(andwei>=128))    //位于第2屏和第3屏之间
  1247.                 {
  1248.                         oddwei=andwei-127;          //位于第3屏的位数
  1249.                         tempwei=8-oddwei;           //位于第2屏
  1250.                         LCD_CS1=0;
  1251.                         LCD_CS2=1;
  1252.                         write_page_8bit(pps,wholepage,y-64,tempwei);
  1253.                        
  1254.                         LCD_CS1=1;
  1255.                         LCD_CS2=0;
  1256.                         write_page_8bit(pps+tempwei,wholepage,0,oddwei);

  1257.                 }
  1258.                 else    //位于第3屏
  1259.                 {
  1260.                         LCD_CS1=1;
  1261.                         LCD_CS2=0;
  1262.                         write_page_8bit(pps,wholepage,y-128,8);
  1263.                 }       

  1264.         }
  1265.         else          //write_xy_nbit(u8 *pbuff,u8 x,u8 y,u8 len)
  1266.         {
  1267.                 if(andwei<64)            //位于第一屏
  1268.                 {
  1269.                         LCD_CS1=0;
  1270.                         LCD_CS2=0;
  1271.                         write_xy_n8bit(pps,x,y,8);
  1272. /*                        for(i=0;i<8;i++)
  1273.                         {
  1274.                                 write_xy_8bit(*pps,x,y+i);
  1275.                                 pps++;
  1276.                         }*/
  1277.                 }
  1278.                 else if((y<64)&&(andwei>=64))    //位于第一屏和第二屏之间
  1279.                 {
  1280.                         oddwei=andwei-63;           //  位于第2屏的位数
  1281.                         tempwei=8-oddwei;           //  位于第1屏的位数
  1282.                         LCD_CS1=0;
  1283.                         LCD_CS2=0;
  1284.                         write_xy_n8bit(pps,x,y,tempwei);
  1285. /*                        for(i=0;i<tempwei;i++)      //位于第1屏
  1286.                         {
  1287.                                 write_xy_8bit(*pps,x,y+i);
  1288.                                 pps++;
  1289.                         }*/
  1290.                
  1291.                         LCD_CS1=0;
  1292.                         LCD_CS2=1;
  1293.                         write_xy_n8bit(pps+tempwei,x,0,oddwei);
  1294. /*                        for(i=0;i<oddwei;i++)     //位于第2屏
  1295.                         {
  1296.                                 write_xy_8bit(*(pps),x,i);
  1297.                                 pps++;
  1298.                         }*/
  1299.                
  1300.                 }
  1301.                 else if((y>=64)&&(andwei<128))     //位于第二屏中
  1302.                 {
  1303.                         LCD_CS1=0;
  1304.                         LCD_CS2=1;
  1305.                         write_xy_n8bit(pps,x,y-64,8);
  1306. /*                        for(i=0;i<8;i++)
  1307.                         {
  1308.                                 write_xy_8bit(*pps,x,y+i-64);
  1309.                                 pps++;
  1310.                         }*/
  1311.                 }
  1312.                 else if((y<128)&&(andwei>=128))    //位于第2屏和第3屏之间
  1313.                 {
  1314.                         oddwei=andwei-127;          //位于第3屏的位数
  1315.                         tempwei=8-oddwei;           //位于第2屏
  1316.                         LCD_CS1=0;
  1317.                         LCD_CS2=1;
  1318.                         write_xy_n8bit(pps,x,y-64,tempwei);
  1319. /*                        for(i=0;i<tempwei;i++)       //位于第2屏
  1320.                         {
  1321.                                 write_xy_8bit(*pps,x,y+i-64);
  1322.                                
  1323.                                 pps++;
  1324.                         }*/
  1325.                         LCD_CS1=1;
  1326.                         LCD_CS2=0;
  1327.                         write_xy_n8bit(pps+tempwei,x,0,oddwei);
  1328. /*                        for(i=0;i<oddwei;i++)        //位于第3屏
  1329.                         {
  1330.                                 write_xy_8bit(*pps,x,i);
  1331.                        
  1332.                                 pps++;
  1333.                         }*/
  1334.                 }
  1335.                 else if(y>=128)   //位于第3屏
  1336.                 {
  1337.                         LCD_CS1=1;
  1338.                         LCD_CS2=0;
  1339.                         write_xy_n8bit(pps,x,y-128,8);
  1340. /*                        for(i=0;i<8;i++)
  1341.                         {
  1342.                                 write_xy_8bit(*pps,x,y+i-128);
  1343.                        
  1344.                                 pps++;
  1345.                         }*/
  1346.                        
  1347.                 }       

  1348. }
  1349. }
  1350. ////////////////////////////////////////////////////////////
  1351. //    函数名:display_str_en
  1352. //    功能  :在任意地址显示字符串   7*8
  1353. //    read_bytes_fromZIC(u8 *pbuffer,u32 addr,u16 len)
  1354. //     tiao shi cheng gong
  1355. ////////////////////////////////////////////////////////////
  1356. void display_str_en8(u8 *text,u8 x,u8 y)
  1357. {
  1358.         u8 i=0;
  1359.         u32 address;
  1360.         u8 pbuffer[10];
  1361.         u8 temp_y;

  1362.         while(text[i]>0)                    //先判断字符的ASCII码是否为0,
  1363.         {
  1364. /*                        LCD_CS1 = 0;
  1365.         LCD_CS2 = 0;
  1366.         LCD_write_command(0xc0);       
  1367.                 LCD_CS1 = 0;
  1368.         LCD_CS2 = 1;
  1369.         LCD_write_command(0xc0);
  1370.                 LCD_CS1 = 1;
  1371.         LCD_CS2 = 0;*/
  1372.         LCD_write_command(0xc0);
  1373.                 temp_y=y+8;                       //判断剩余列数是否可以写完一个字符
  1374.                 if(temp_y>192)                    //如果剩余列数小于8
  1375.                 {
  1376.                         x+=8;                           // 行地址增加一页,列地址为0
  1377.                         y=0;
  1378.           }
  1379.                 address=(text[i]-0x20)*8+0x66c0;  //取点阵地址
  1380.                 read_bytes_fromZIC(pbuffer,address,8);   //取点阵数据,存储在 pbuffer
  1381.                 write_7x8_English(pbuffer, x, y);      //xian shi
  1382.                 i+=1;                                 //字符地址加1,
  1383.                 y+=8;                                // 列数加8
  1384.                 IWDG_Feed();
  1385.         }
  1386. }
  1387. /////////////////////////////////////////////////////////
  1388. //     函数名: display_str_en16
  1389. //     功能  : 显示 8*16字符
  1390. //   tiaoshi cheng gong
  1391. ///////////////////////////////////////////////////
  1392. void display_str_en16(u8 *text,u8 x,u8 y)
  1393. {
  1394.         u8 i=0;
  1395.         u32 address;
  1396.         u8 pbuffer[18];
  1397.         u8 temp_y;
  1398.         while(text[i]>0)                    //先判断字符的ASCII码是否为0,
  1399.         {
  1400.                 temp_y=y+16;                       //判断剩余列数是否可以写完一个字符
  1401.                 if(temp_y>191)                    //如果剩余列数小于8
  1402.                 {
  1403.                         x+=8;                           // 行地址增加一页,列地址为0
  1404.                         y=0;
  1405.           }
  1406.                 address=(u32)((text[i]-0x20)*16+0x3b7c0);  //取点阵地址
  1407.                 read_bytes_fromZIC(pbuffer,address,16);   //取点阵数据,存储在 pbuffer
  1408.                 write_8x16_English(pbuffer, x, y);      //xian shi
  1409.                 i+=1;                                 //字符地址加1,
  1410.                 y+=8;                                // 列数加8
  1411.         }
  1412. }
  1413. ////////////////////////////////////////////////////////////
  1414. //   函数名:write_xy_ch
  1415. //   功能  :在任意的行和列写一个汉字
  1416. //   1个汉字占用32个字节,占16行16列
  1417. //     tiao shi cheng gong
  1418. //    write_page_8bit(u8 *buffer,u8 page,u8 y,u8 n)
  1419. ////////////////////////////////////////////////////////////
  1420. void write_xy_15x16_ch(u8 *p,u8 x,u8 y)
  1421. {
  1422.         u8 wholepage;
  1423.         u8 oddpage;
  1424.         u8 andwei=0;
  1425.         u8 oddwei=0;
  1426.         u8 tempwei=0;
  1427.         oddpage = x%8;
  1428.         wholepage = x/8;
  1429.         andwei=y+15;

  1430.         if(oddpage==0)
  1431.         {
  1432.                 if(andwei<64)               //在第1屏中
  1433.                 {
  1434.                         LCD_CS1=0;
  1435.                         LCD_CS2=0;
  1436.                         write_page_8bit(p,wholepage,y,16);         //上左字节
  1437.                         write_page_8bit(p+16,wholepage+1,y,16);  //下左字节

  1438.                 }
  1439.                 else if((y<64)&&(andwei>=64))   //在第1屏和第2屏之间
  1440.                 {
  1441.                         oddwei=andwei-63;
  1442.                         tempwei=16-oddwei;
  1443.                         LCD_CS1=0;
  1444.                         LCD_CS2=0;
  1445.                         write_page_8bit(p,wholepage,y,tempwei);
  1446.                         write_page_8bit(p+16,wholepage+1,y,tempwei);

  1447.                         LCD_CS1=0;
  1448.                         LCD_CS2=1;
  1449.                         write_page_8bit(p+tempwei,wholepage,0,oddwei);
  1450.                         write_page_8bit((p+16+tempwei),wholepage+1,0,oddwei);       

  1451.                 }
  1452.                 else if((y>=64)&&(andwei<128))   //位于第2屏中
  1453.                 {
  1454.                         LCD_CS1=0;
  1455.                         LCD_CS2=1;
  1456.                         write_page_8bit(p,wholepage,y-64,16);
  1457.                         write_page_8bit(p+16,wholepage+1,y-64,16);       
  1458.                 }
  1459.                 else if((y<128)&&(andwei>=128))    //位于第2屏和第3屏之间
  1460.                 {
  1461.                         oddwei=andwei-127;
  1462.                         tempwei=16-oddwei;
  1463.                         LCD_CS1=0;
  1464.                         LCD_CS2=1;
  1465.                         write_page_8bit(p,wholepage,y-64,tempwei);
  1466.                         write_page_8bit(p+16,wholepage+1,y-64,tempwei);

  1467.                         LCD_CS1=1;
  1468.                         LCD_CS2=0;
  1469.                         write_page_8bit(p+tempwei,wholepage,0,oddwei);
  1470.                         write_page_8bit(p+16+tempwei,wholepage+1,0,oddwei);       

  1471.                 }
  1472.                 else if(y>=128)    //位于第3屏中
  1473.                 {
  1474.                         LCD_CS1=1;
  1475.                         LCD_CS2=0;
  1476.                         write_page_8bit(p,wholepage,y-128,16);
  1477.                         write_page_8bit(p+16,wholepage+1,y-128,16);
  1478.                 }
  1479.         }
  1480.         else
  1481.         {
  1482.                 if(andwei<64)               //在第1屏中
  1483.                 {
  1484.                         LCD_CS1=0;
  1485.                         LCD_CS2=0;
  1486.                         write_xy_n8bit(p,x,y,16);
  1487.                         write_xy_n8bit(p+16,x+8,y,16);
  1488. /*                        for(i=0;i<8;i++)
  1489.                         {
  1490.                                 write_xy_8bit(*p,x,y+i);         //上左字节
  1491.                                 write_xy_8bit(*(p+8),x,y+8+i);   //上右字节
  1492.                                 write_xy_8bit(*(p+16),x+8,y+i);  //下左字节
  1493.                                 write_xy_8bit(*(p+24),x+8,y+8+i); //下右字节
  1494.                                 p++;       
  1495.                         }*/
  1496.                                
  1497.                 }
  1498.                 else if((y<64)&&(andwei>=64))   //在第1屏和第2屏之间
  1499.                 {
  1500.                         oddwei=andwei-63;
  1501.                         tempwei=16-oddwei;
  1502.                         LCD_CS1=0;
  1503.                         LCD_CS2=0;
  1504.                         write_xy_n8bit(p,x,y,tempwei);
  1505.                         write_xy_n8bit(p+16,x+8,y,tempwei);
  1506.         /*                for(i=0;i<tempwei;i++)
  1507.                         {
  1508.                                 write_xy_8bit(*p,x,y+i);
  1509.                                 write_xy_8bit(*(p+16),x+8,y+i);
  1510.                                 p++;       
  1511.                         }*/
  1512.                         LCD_CS1=0;
  1513.                         LCD_CS2=1;
  1514.                         write_xy_n8bit(p+tempwei,x,0,oddwei);
  1515.                         write_xy_n8bit(p+16+tempwei,x+8,0,oddwei);
  1516. /*                        for(i=0;i<oddwei;i++)
  1517.                         {
  1518.                                 write_xy_8bit(*p,x,i);
  1519.                                 write_xy_8bit(*(p+16),x+8,i);       
  1520.                                 p++;
  1521.                         }*/       
  1522.                 }
  1523.                 else if((y>=64)&&(andwei<128))   //位于第2屏中
  1524.                 {
  1525.                         LCD_CS1=0;
  1526.                         LCD_CS2=1;
  1527.                         write_xy_n8bit(p,x,y-64,16);
  1528.                         write_xy_n8bit(p+16,x+8,y-64,16);
  1529. /*                        for(i=0;i<8;i++)
  1530.                         {
  1531.                                 write_xy_8bit(*p,x,y+i-64);
  1532.                                 write_xy_8bit(*(p+8),x,y+i-56);
  1533.                                 write_xy_8bit(*(p+16),x+8,y+i-64);
  1534.                                 write_xy_8bit(*(p+24),x+8,y+i-56);       
  1535.                                 p++;
  1536.                         }                */
  1537.                 }
  1538.                 else if((y<128)&&(andwei>=128))    //位于第2屏和第3屏之间
  1539.                 {
  1540.                         oddwei=andwei-127;
  1541.                         tempwei=16-oddwei;
  1542.                         LCD_CS1=0;
  1543.                         LCD_CS2=1;
  1544.                         write_xy_n8bit(p,x,y-64,tempwei);
  1545.                         write_xy_n8bit(p+16,x+8,y-64,tempwei);
  1546. /*                        for(i=0;i<tempwei;i++)
  1547.                         {
  1548.                                 write_xy_8bit(*p,x,y+i-64);
  1549.                                 write_xy_8bit(*(p+16),x+8,y+i-64);
  1550.                                 p++;       
  1551.                         }*/
  1552.                         LCD_CS1=1;
  1553.                         LCD_CS2=0;
  1554.                         write_xy_n8bit(p+tempwei,x,0,oddwei);
  1555.                         write_xy_n8bit(p+16+tempwei,x+8,0,oddwei);
  1556. /*                        for(i=0;i<oddwei;i++)
  1557.                         {

  1558.                                 write_xy_8bit(*p,x,i);
  1559.                                 write_xy_8bit(*(p+16),x+8,i);       
  1560.                                 p++;
  1561.                         }        */
  1562.                 }
  1563.                 else if((y>=128)&&(andwei<192))    //位于第3屏中
  1564.                 {
  1565.                         LCD_CS1=1;
  1566.                         LCD_CS2=0;
  1567.                         write_xy_n8bit(p,x,y-128,16);
  1568.                         write_xy_n8bit(p+16,x+8,y-128,16);
  1569.         /*                for(i=0;i<8;i++)
  1570.                         {
  1571.                                 write_xy_8bit(*p,x,y+i-128);
  1572.                                 write_xy_8bit(*(p+8),x,y+i-120);
  1573.                                 write_xy_8bit(*(p+16),x+8,y+i-128);
  1574.                                 write_xy_8bit(*(p+24),x+8,y+i-120);       
  1575.                                 p++;
  1576.                         }        */
  1577.                 }
  1578.         }

  1579. }

  1580. /////////////////////////////////////////////////////
  1581. //     函数名:write_xy_11x12_ch
  1582. //     功能  :在任意的地址写1个11x12的汉字
  1583. //     1个汉字占11列12行,24个字节
  1584. //   tiao shi cheng gong
  1585. //////////////////////////////////////////////////////
  1586. void write_xy_11x12_ch(u8 *p,u8 x,u8 y)
  1587. {
  1588.         u8 i;
  1589.         u8 andwei;
  1590.         u8 oddwei;
  1591.         u8 oddwei_1;
  1592.         u8 tempwei;
  1593.         u8 tempwei_1;
  1594.         andwei=y+11;
  1595.        
  1596.         if(andwei<64)          //在第1屏中
  1597.         {
  1598.                 LCD_CS1=0;
  1599.                 LCD_CS2=0;
  1600.                 for(i=0;i<12;i++)
  1601.                 {
  1602.                         write_xy_8bit(*p,x,y+i);       //上字节
  1603.                         write_xy_8bit(*(p+12),x+8,y+i);  //下字节
  1604.                         p++;       
  1605.                 }
  1606.                        
  1607.         }
  1608.         else if((y<64)&&(andwei>=64))   //在第1屏和第2屏之间
  1609.         {
  1610.                 oddwei=andwei-63;
  1611.                 tempwei=12-oddwei;
  1612.                 LCD_CS1=0;
  1613.                 LCD_CS2=0;
  1614.                 for(i=0;i<tempwei;i++)
  1615.                 {
  1616.                         write_xy_8bit(*p,x,y+i);
  1617.         //                writedata_8bit(*(p+8),x,y+8+i);
  1618.                         write_xy_8bit(*(p+12),x+8,y+i);
  1619.         //                writedata_8bit(*(p+24),x+8,y+8+i);
  1620.                         p++;       
  1621.                 }
  1622.                 LCD_CS1=0;
  1623.                 LCD_CS2=1;;
  1624.                 for(i=0;i<oddwei;i++)
  1625.                 {
  1626.         //                writedata_8bit(*p,x,y+i);
  1627.                         write_xy_8bit(*p,x,i);
  1628.         //                writedata_8bit(*(p+16),x+8,y+i);
  1629.                         write_xy_8bit(*(p+12),x+8,i);       
  1630.                         p++;
  1631.                 }       
  1632.         }
  1633.         else if((y>=64)&&(andwei<=128))   //位于第2屏中
  1634.         {
  1635.                 LCD_CS1=0;
  1636.                 LCD_CS2=1;
  1637.                 for(i=0;i<12;i++)
  1638.                 {
  1639.                         write_xy_8bit(*p,x,y+i-64);
  1640.                         write_xy_8bit(*(p+12),x+8,y+i-64);
  1641.                         p++;
  1642.                 }               
  1643.         }
  1644.         else if((y<128)&&(andwei>=128))    //位于第2屏和第3屏之间
  1645.         {
  1646.                 oddwei_1=andwei-127;
  1647.                 tempwei_1=12-oddwei_1;
  1648.                 LCD_CS1=0;
  1649.                 LCD_CS2=1;
  1650.                 for(i=0;i<tempwei_1;i++)
  1651.                 {
  1652.                         write_xy_8bit(*p,x,y+i-64);
  1653.         //                writedata_8bit(*(p+8),x,y+8+i);
  1654.                         write_xy_8bit(*(p+12),x+8,y+i-64);
  1655.         //                writedata_8bit(*(p+24),x+8,y+8+i);
  1656.                         p++;       
  1657.                 }
  1658.                 LCD_CS1=1;
  1659.                 LCD_CS2=0;;
  1660.                 for(i=0;i<oddwei_1;i++)
  1661.                 {
  1662.         //                writedata_8bit(*p,x,y+i);
  1663.                         write_xy_8bit(*p,x,i);
  1664.         //                writedata_8bit(*(p+16),x+8,y+i);
  1665.                         write_xy_8bit(*(p+12),x+8,i);       
  1666.                         p++;
  1667.                 }       
  1668.         }
  1669.         else if((y>=128)&&(andwei<192))    //位于第3屏中
  1670.         {
  1671.                 LCD_CS1=1;
  1672.                 LCD_CS2=0;
  1673.                 for(i=0;i<12;i++)
  1674.                 {
  1675.                         write_xy_8bit(*p,x,y+i-128);
  1676.                         write_xy_8bit(*(p+12),x+8,y+i-128);       
  1677.                         p++;
  1678.                 }       
  1679.         }
  1680. /*        else if((y<192)&&(andwei>=192))
  1681.         {
  1682.                 LCD_CS1=0;
  1683.                 LCD_CS2=0;
  1684.                 for(i=0;i<12;i++)
  1685.                 {
  1686.                         write_xy_8bit(*p,x+12,i);
  1687.                         write_xy_8bit(*(p+12),x+20,i);       
  1688.                         p++;
  1689.                 }       
  1690.         }*/       
  1691. }
  1692. /////////////////////////////////////////////////////////////
  1693. //     函数名: display_str_gb2312
  1694. //     功能  :显示文本,字符 (7x8)汉字(11x12)
  1695. //    一个汉字占用两个ASCII码
  1696. //    tiao shi cheng gong
  1697. /////////////////////////////////////////////////////////////
  1698. void display_str_gb2312(u8 *text,u8 x,u8 y)
  1699. {
  1700.         u8 i=0;
  1701.         u8 buffer1[26];
  1702.         u8 buffer2[10];
  1703.         u8 temp_y;
  1704.         u32 address;
  1705.         while(text[i]>0)
  1706.         {
  1707.                 if((text[i] >=(0xA1-0xa0)) && (text[i] <= (0Xa3-0xa0)) && (text[i+1] >=(0xA1-0xa0)))
  1708.                 {
  1709.                         temp_y=y+12;
  1710.                         if(temp_y>191)
  1711.                         {
  1712.                                 x+=12;
  1713.                                 y=0;
  1714.                         }
  1715.                         text[i] = text[i] + 0xa0 ;
  1716.                         address =(u32)(((text[i]-0xA1)*94 +(text[i+1] - 0xA1))*24+ 0x3cf80);
  1717.                         read_bytes_fromZIC(buffer1,address,24);
  1718.                         write_xy_11x12_ch(buffer1, x, y);
  1719.                         i+=2;
  1720.                         y+=12;
  1721.                 }
  1722.                 else if((text[i] == (0Xa9-0xa0)) && (text[i+1] >=(0xA1-0xa0)))
  1723.                 {
  1724.                         temp_y=y+12;
  1725.                         if(temp_y>191)
  1726.                         {
  1727.                                 x+=12;
  1728.                                 y=0;
  1729.                         }
  1730.                         text[i] = text[i] + 0xa0 ;
  1731.                         address =(u32)((282 + (text[i+1] - 0xA1))*24+ 0x3cf80);
  1732.                         read_bytes_fromZIC(buffer1,address,24);
  1733.                         write_xy_11x12_ch(buffer1, x, y);
  1734.                         i+=2;
  1735.                         y+=12;
  1736.                 }
  1737.                 else if((text[i] >=(0xB0-0xa0)) && (text[i] <= (0xF7-0xa0)) && (text[i+1] >=(0xA1-0xa0)))
  1738.                 {
  1739.                         temp_y=y+12;
  1740.                         if(temp_y>191)
  1741.                         {
  1742.                                 x+=12;
  1743.                                 y=0;
  1744.                         }
  1745.                         text[i] = text[i] + 0xa0 ;
  1746.                         address = (u32)(((text[i] - 0xB0) * 94 + (text[i+1] - 0xA1)+ 376)*24+ 0x3cf80);
  1747.                         read_bytes_fromZIC(buffer1,address,24);
  1748.                         write_xy_11x12_ch(buffer1, x, y);
  1749.                         i+=2;
  1750.                         y+=12;
  1751.                 }
  1752.                 else if ((text[i] >= 0x20) && (text[i] <= 0x7E))
  1753.                 {
  1754.                         temp_y=y+8;                       //判断剩余列数是否可以写完一个字符
  1755.                         if(temp_y>191)                    //如果剩余列数小于8
  1756.                         {
  1757.                                 x+=12;                           // 行地址增加一页,列地址为0
  1758.                                 y=0;
  1759.                         }
  1760.                         address=(u32)((text[i]-0x20)*8+0x66c0);  //取点阵地址
  1761.                         read_bytes_fromZIC(buffer2,address,8);   //取点阵数据,存储在 pbuffer
  1762.                         write_7x8_English(buffer2, x, y);      //xian shi
  1763.                         i+=1;                                 //字符地址加1,
  1764.                         y+=8;                                // 列数加8
  1765.                 }
  1766.                 else
  1767.                         break;
  1768.         }
  1769. }
  1770. ///////////////////////////////////////////////////////////////
  1771. //    函数名:display_str_15x16_ch
  1772. //    功能  :显示15x16汉字串
  1773. //    调试成功
  1774. ///////////////////////////////////////////////////////////////
  1775. void display_str_15x16_ch(u8 *text,u8 x,u8 y)
  1776. {
  1777.         u8 i=0;
  1778.         u8 buffer[34];
  1779.         u8 temp_y;
  1780.         u32 address;
  1781.        
  1782.         while(text[i]>0)
  1783.         {

  1784.                 LCD_write_command(0xc0);
  1785.                 IWDG_Feed();
  1786.                
  1787.                 if((text[i] >=0xA4) && (text[i] <= 0Xa8) && (text[i+1] >=0xA1))
  1788.                 {
  1789.                         temp_y=y+16;
  1790.                         if(temp_y>192)
  1791.                         {
  1792.                                 x+=16;
  1793.                                 y=0;
  1794.                         }
  1795.                         address=0;
  1796.                         read_bytes_fromZIC(buffer,address,32);
  1797.                         write_xy_15x16_ch( buffer, x, y);
  1798.                         i+=2;
  1799.                         y+=16;
  1800.                 }
  1801.                 else if((text[i] >=0xA1) && (text[i] <= 0Xa9) && (text[i+1] >=0xA1))
  1802.                 {
  1803.                         temp_y=y+16;
  1804.                         if(temp_y>192)
  1805.                         {
  1806.                                 x+=16;
  1807.                                 y=0;
  1808.                         }
  1809.                         address =((text[i] - 0xA1) * 94 + (text[i+1] - 0xA1))*32;

  1810.                         read_bytes_fromZIC(buffer,address,32);
  1811.                         write_xy_15x16_ch( buffer, x, y);
  1812.                         i+=2;
  1813.                         y+=16;
  1814.                 }
  1815.                 else if((text[i] >=0xB0 )&& (text[i] <= 0xF7) && (text[i+1] >=0xA1))
  1816.                 {
  1817.                         temp_y=0;
  1818.                         temp_y=y+16;
  1819.                         if(temp_y>192)
  1820.                         {
  1821.                                 x+=16;
  1822.                                 y=0;
  1823.                         }
  1824.                         address = ((text[i] - 0xB0) * 94 + (text[i+1] - 0xA1)+ 846)*32;

  1825.                         read_bytes_fromZIC(buffer,address,32);
  1826.                         write_xy_15x16_ch( buffer, x, y);
  1827.                         i+=2;
  1828.                         y+=16;
  1829.                 }
  1830.                 else
  1831.                 {
  1832.                         break;
  1833.                 }
  1834.                
  1835.         }
  1836. }
  1837. ///////////////////////////////////////////////////////////////////////////
  1838. //           函数名 :write_wherepage_8bit
  1839. //           功能   :在一页的指定地址写1列数据
  1840. //
  1841. ///////////////////////////////////////////////////////////////////////////
  1842. void write_wherepage_8bit(u8 data,u8 page,u8 y)
  1843. {

  1844.         if(y<64)
  1845.         {
  1846.                 LCD_CS1 = 0;
  1847.                 LCD_CS2 = 0;
  1848.                 LCD_write_command(0xc0);
  1849.                 write_page_8bit(&data,page,y,1);
  1850.         }
  1851.         else if((y>=64)&&(y<128))
  1852.         {
  1853.                 LCD_CS1 = 0;
  1854.                 LCD_CS2 = 1;
  1855.                 LCD_write_command(0xc0);
  1856.                 write_page_8bit(&data,page,y-64,1);
  1857.         }
  1858.         else
  1859.         {
  1860.                 LCD_CS1 = 1;
  1861.                 LCD_CS2 = 0;
  1862.                 LCD_write_command(0xc0);
  1863.                 write_page_8bit(&data,page,y-128,1);
  1864.         }
  1865.        
  1866. }
  1867. ///////////////////////////////////////////////////////////////////////////
  1868. //           函数名 :write_wherepage_nbit
  1869. //           功能   :在一页的指定地址写n列数据  ,数据不超过一页
  1870. //
  1871. ///////////////////////////////////////////////////////////////////////////
  1872. void write_wherepage_nbit(u8 *ps,u8 page,u8 y,u8 len)
  1873. {
  1874.         u8 i;
  1875.         for(i=0;i<len;i++)
  1876.         {
  1877.                 write_wherepage_8bit(*ps,page,y+i) ;
  1878.                 ps++;
  1879.         }
  1880. }
  1881. ///////////////////////////////////////////////////////////////
  1882. //        函数名: write_string_dat
  1883. //        功能  :在指定的地址写入n列数据串
  1884. //       write_xy_8bit(u8 datt,u8 x,u8 y)
  1885. //       write_page_8bit(u8 *buffer,u8 page,u8 y,u8 n)
  1886. ////////////////////////////////////////////////////////////////
  1887. void write_string_dat(u8 h_addr,u8 l_addr,u8 *ps,u16 len)
  1888. {
  1889.         u8 where_page,where_y;
  1890.         u8 remain_y;
  1891.         u16 Address;
  1892.         Address = (u16)(h_addr<<8);
  1893.         Address = Address + l_addr;
  1894.         where_page = Address/192 ;     //把总的地址变为 页地址 和 列地址
  1895.         where_y    = Address%192 ;
  1896.         remain_y   = 192 - where_y ;     //在起始页中剩余的列数
  1897.         if(len<=remain_y) remain_y = len ;   //如果要写入的数据长度小于起始页中剩余的列数,则把长度字节赋予列数字节
  1898.         while(1)
  1899.         {
  1900.                 write_wherepage_nbit(ps,where_page,where_y,remain_y) ;    //在指定的页指定的列写入remain_y个数据
  1901.                 if(len==remain_y) break;                                //如果 len 与 remain_y 相等,则退出循环
  1902.                 else     //len > remain_y
  1903.                 {
  1904.                         ps += remain_y ;                         //数组数据地址加remain_y
  1905.                         where_page += 1;                        //页地址加一
  1906.                         where_y = 0;                           //列地址归零
  1907.                        
  1908.                         len = len - remain_y;               //数据长度减去remain_y
  1909.                         if(len>=192)remain_y=192 ;          //如果剩余的数据长度大于192,则把192赋予remain_y
  1910.                         else remain_y = len ;               //否则,把len 赋予remain_y
  1911.                 }
  1912.         }
  1913. }


复制代码


LCD.rar

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

19264屏

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励!

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏2 转播转播 分享分享 分享淘帖 顶 踩
回复

使用道具 举报

沙发
fsss007 发表于 2016-7-10 20:56 | 只看该作者
这个我收藏了,很有用哦
回复

使用道具 举报

板凳
w0can 发表于 2016-9-6 17:13 | 只看该作者
不错,借鉴一下
回复

使用道具 举报

地板
jor 发表于 2016-10-29 13:11 来自手机 | 只看该作者
楼主有联系qq号给我
回复

使用道具 举报

5#
jor 发表于 2016-10-29 13:13 来自手机 | 只看该作者
我的1023010634请你吃大餐加我
回复

使用道具 举报

6#
eric9779 发表于 2016-12-8 15:18 | 只看该作者
很不错,收藏一下看看
回复

使用道具 举报

7#
xiexiaoshuyan 发表于 2016-12-19 23:17 | 只看该作者
挺有用的,受益颇多
回复

使用道具 举报

8#
sam851217 发表于 2017-2-6 22:40 | 只看该作者
这个我收藏了,很有用哦
回复

使用道具 举报

9#
无效楼层,该帖已经被删除
10#
yifabin023 发表于 2017-2-8 00:43 | 只看该作者
收藏,有用
回复

使用道具 举报

11#
wangweiguo2002 发表于 2017-4-4 21:38 | 只看该作者
这个我收藏了,很有用哦
回复

使用道具 举报

12#
xinruan 发表于 2017-5-2 20:19 | 只看该作者
这个我收藏了,谢谢!
回复

使用道具 举报

13#
lqb7733 发表于 2017-6-29 13:39 | 只看该作者
不错!!!!!!!!!!!!!!
回复

使用道具 举报

14#
liyidage 发表于 2017-6-29 17:10 | 只看该作者
有项目要用,学习了
回复

使用道具 举报

15#
启发 发表于 2017-7-6 14:31 | 只看该作者
好&nbsp; &nbsp; 这个不错!!正需要呢
回复

使用道具 举报

16#
wangweiguo2002 发表于 2017-9-16 10:12 | 只看该作者
很好的程序  谢谢啦
回复

使用道具 举报

17#
Rongling 发表于 2017-10-17 13:22 | 只看该作者
正缺这个东西呢
回复

使用道具 举报

18#
120299797 发表于 2017-11-20 16:44 | 只看该作者
h文件跟c文件都下载
回复

使用道具 举报

19#
120299797 发表于 2017-11-29 16:11 | 只看该作者
非常感谢
回复

使用道具 举报

20#
inmoment 发表于 2018-1-23 10:01 | 只看该作者
您好:我用这个程序没有显示啊好难受
回复

使用道具 举报

21#
LIMBOS 发表于 2018-4-19 19:36 | 只看该作者
不错刚好在整理这方面资料
回复

使用道具 举报

22#
jingcolin 发表于 2018-7-18 15:00 | 只看该作者
这个很有好,正好学习用,楼主给力啊
回复

使用道具 举报

23#
jingcolin 发表于 2018-7-18 15:01 | 只看该作者
这个正合适新手学习使用,楼主给力啊
回复

使用道具 举报

24#
xo37 发表于 2019-2-2 14:00 | 只看该作者
19264 都是3片选的,好像……
回复

使用道具 举报

25#
zmr1992 发表于 2019-2-12 09:34 | 只看该作者
想下载····分不够······
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

QQ|手机版|小黑屋|单片机论坛 |51黑电子论坛单片机.

Powered by 单片机教程网

快速回复 返回顶部 返回列表