开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > uCOS > 查看源码
LCDMem.c
资源名称：mini2440_uCos2_ucgui.rar　[点击查看]
上传用户：zbk8730
上传日期：2017-08-10
资源大小：12168k
文件大小：16k
源码类别：

uCOS

开发平台：

C/C++

LCDMem.c：源码内容
  1. /*
  2. *********************************************************************************************************
  3. *                                                uC/GUI
  4. *                        Universal graphic software for embedded applications
  5. *
  6. *                       (c) Copyright 2002, Micrium Inc., Weston, FL
  7. *                       (c) Copyright 2002, SEGGER Microcontroller Systeme GmbH
  8. *
  9. *              礐/GUI is protected by international copyright laws. Knowledge of the
  10. *              source code may not be used to write a similar product. This file may
  11. *              only be used in accordance with a license and should not be redistributed
  12. *              in any way. We appreciate your understanding and fairness.
  13. */
  15. #include <string.h>             /* for memset */
  16. #include <stddef.h>           /* needed for definition of NULL */
  17. #include "LCD_Private.h"      /* private modul definitions & config */
  18. #include "GUI_Private.h"
  19. #include "GUIDebug.h"
  20. #include "LCD_0.h"            /* Defines for first display */
  22. #include "2440addr.h"
  23. #include "2440lib.h"
  24. #include "2440slib.h"
  25. #include "lcdlib.h"
  26. #include "glib.h"
  27. #include "2440lcd.h"
  28. #include "DEMO256.h"
  29. #include "LCDMem.h"
  31. /**************************************************************
  32. The initial and control for 320×240 16Bpp TFT LCD----LCD_LTV350QV-F04
  33. **************************************************************/
  34. #include <stdarg.h>
  35. #include <string.h>
  36. #include <stdlib.h>
  37. #include <stdio.h>
  38. #include <ctype.h>
  40. #include "option.h"
  41. #include "2440addr.h"
  42. #include "2440lib.h"
  43. #include "2440slib.h" 
  44. #include "lcd.h"
  47. #define MVAL (13)
  48. #define MVAL_USED  (0) //0=each frame   1=rate by MVAL
  49. #define INVVDEN (1) //0=normal       1=inverted
  50. #define BSWP (0) //Byte swap control
  51. #define HWSWP (1) //Half word swap control
  53. #define M5D(n) ((n) & 0x1fffff) // To get lower 21bits
  56. //TFT 240320
  57. #define LCD_TFT_XSIZE  (240)
  58. #define LCD_TFT_YSIZE  (320)
  60. #define SCR_XSIZE_TFT  (240)
  61. #define SCR_YSIZE_TFT  (320)
  63. //TFT240320
  64. #define HOZVAL_TFT (LCD_TFT_XSIZE-1)
  65. #define LINEVAL_TFT (LCD_TFT_YSIZE-1)
  67. //Timing parameter for LCD LQ035Q7DB02
  68. #define VBPD (1) //垂直同步信号的后肩
  69. #define VFPD (5) //垂直同步信号的前肩
  70. #define VSPW (1) //垂直同步信号的脉宽
  72. #define HBPD (35) //水平同步信号的后肩
  73. #define HFPD (19) //水平同步信号的前肩
  74. #define HSPW (5) //水平同步信号的脉宽
  76. #define CLKVAL_TFT (4) 
  82. // GPB1/TOUT1 for Backlight control(PWM)
  83. #define GPB1_TO_OUT()   (rGPBUP &= 0xfffd, rGPBCON &= 0xfffffff3, rGPBCON |= 0x00000004)
  84. #define GPB1_TO_1()     (rGPBDAT |= 0x0002)
  85. #define GPB1_TO_0()     (rGPBDAT &= 0xfffd)
  87. //extern void Uart_Printf(char *f, ...) ;
  89. extern unsigned char __CHS[];
  90. extern unsigned char __VGA[];
  92. volatile static unsigned short LCD_BUFFER[SCR_YSIZE_TFT][SCR_XSIZE_TFT];
  94. #ifndef  LCD_BUSWIDTH
  95. #define  LCD_BUSWIDTH   16
  96. #endif 
  98. #define BKCOLOR LCD_BKCOLORINDEX
  99. #define   COLOR LCD_COLORINDEX
  103. static void  _DrawBitLine1BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  104.   LCD_PIXELINDEX Index0 = *(pTrans+0);
  105.   LCD_PIXELINDEX Index1 = *(pTrans+1);
  106.   x += Diff;
  107.   switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR)) {
  108.     case 0:
  109.       do {
  110.         LCD_L0_SetPixelIndex(x++, y, (*p & (0x80 >> Diff)) ? Index1 : Index0);
  111. if (++Diff == 8) {
  112.                Diff = 0;
  113.   p++;
  114.         }
  115.   } while (--xsize);
  116.       break;
  117.     case LCD_DRAWMODE_TRANS:
  118.       do {
  119.       if (*p & (0x80 >> Diff))
  120.           LCD_L0_SetPixelIndex(x, y, Index1);
  121.            x++;
  122.   if (++Diff == 8) {
  123.                         Diff = 0;
  124.    p++;
  125.   }
  126.   } while (--xsize);
  127.       break;
  128.     case LCD_DRAWMODE_XOR:;
  129.       do {
  130.      if (*p & (0x80 >> Diff)) {
  131.           int Pixel = LCD_L0_GetPixelIndex(x, y);
  132.           LCD_L0_SetPixelIndex(x, y, LCD_NUM_COLORS - 1 - Pixel);
  133.               }
  134.                 x++;
  135.   if (++Diff == 8) {
  136.                       Diff = 0;
  137.  p++;
  138.   }
  139.   } while (--xsize);
  140.       break;
  141. }
  142. }
  145. /*********************************************
  146. *
  147. *       Draw Bitmap 2 BPP
  148. *
  149. **********************************************
  150. */
  152. #if (LCD_MAX_LOG_COLORS > 2)
  153. static void  _DrawBitLine2BPP(int x, int y, U8 const * p, int Diff, int xsize, const LCD_PIXELINDEX * pTrans) {
  154.   LCD_PIXELINDEX Pixels = *p;
  155.   int CurrentPixel = Diff;
  156.   x += Diff;
  157.   switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR)) {
  158.     case 0:
  159.       do {
  160.         int Shift = (3 - CurrentPixel) << 1;
  161.         int Index = (Pixels & (0xC0 >> (6 - Shift))) >> Shift;
  162.         LCD_PIXELINDEX PixelIndex = *(pTrans + Index);
  163.         LCD_L0_SetPixelIndex(x++, y, PixelIndex);
  164.         if (++CurrentPixel == 4) {
  165.           CurrentPixel = 0;
  166.           Pixels = *(++p);
  167.         }
  168.   } while (--xsize);
  169.       break;
  170.     case LCD_DRAWMODE_TRANS:
  171.       do {
  172.         int Shift = (3 - CurrentPixel) << 1;
  173.         int Index = (Pixels & (0xC0 >> (6 - Shift))) >> Shift;
  174.         if (Index) {
  175.           LCD_PIXELINDEX PixelIndex = *(pTrans + Index);
  176.           LCD_L0_SetPixelIndex(x, y, PixelIndex);
  177.         }
  178.         x++;
  179.         if (++CurrentPixel == 4) {
  180.           CurrentPixel = 0;
  181.           Pixels = *(++p);
  182.         }
  183.   } while (--xsize);
  184.       break;
  185.   }
  186. }
  187. #endif
  189. /*********************************************
  190. *
  191. *       Draw Bitmap 4 BPP
  192. *
  193. **********************************************
  194. */
  196. #if (LCD_MAX_LOG_COLORS > 4)
  197. static void  _DrawBitLine4BPP(int x, int y, U8 const * p, int Diff, int xsize, const LCD_PIXELINDEX * pTrans) {
  198.   LCD_PIXELINDEX Pixels = *p;
  199.   int CurrentPixel = Diff;
  200.   switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR)) {
  201.     case 0:
  202.       do {
  203.         int Shift = (1 - CurrentPixel) << 2;
  204.         int Index = (Pixels & (0xF0 >> (4 - Shift))) >> Shift;
  205.         LCD_PIXELINDEX PixelIndex = *(pTrans + Index);
  206.         LCD_L0_SetPixelIndex(x++, y, PixelIndex);
  207.         if (++CurrentPixel == 2) {
  208.           CurrentPixel = 0;
  209.           Pixels = *(++p);
  210.         }
  211.   } while (--xsize);
  212.       break;
  213.     case LCD_DRAWMODE_TRANS:
  214.       do {
  215.         int Shift = (1 - CurrentPixel) << 2;
  216.         int Index = (Pixels & (0xF0 >> (4 - Shift))) >> Shift;
  217.         if (Index) {
  218.           LCD_PIXELINDEX PixelIndex = *(pTrans + Index);
  219.           LCD_L0_SetPixelIndex(x, y, PixelIndex);
  220.         }
  221.         x++;
  222.         if (++CurrentPixel == 2) {
  223.           CurrentPixel = 0;
  224.           Pixels = *(++p);
  225.         }
  226.   } while (--xsize);
  227.       break;
  228.   }
  229. }
  230. #endif
  232. /*********************************************
  233. *
  234. *       Draw Bitmap 8 BPP
  235. *
  236. **********************************************
  237. */
  239. #if (LCD_MAX_LOG_COLORS > 16)
  240. static void  _DrawBitLine8BPP(int x, int y, U8 const * p, int xsize, const LCD_PIXELINDEX * pTrans) {
  241.   LCD_PIXELINDEX Pixel;
  242.   switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR)) {
  243.     case 0:
  244.       if (pTrans) {
  245.         for (; xsize > 0; xsize--, x++, p++) {
  246.           Pixel = *p;
  247.           LCD_L0_SetPixelIndex(x, y, *(pTrans + Pixel));
  248.         }
  249.       } else {
  250.         for (; xsize > 0; xsize--, x++, p++) {
  251.           LCD_L0_SetPixelIndex(x, y, *p);
  252.         }
  253.       }
  254.       break;
  255.     case LCD_DRAWMODE_TRANS:
  256.       if (pTrans) {
  257.         for (; xsize > 0; xsize--, x++, p++) {
  258.           Pixel = *p;
  259.           if (Pixel) {
  260.             LCD_L0_SetPixelIndex(x, y, *(pTrans + Pixel));
  261.           }
  262.         }
  263.       } else {
  264.         for (; xsize > 0; xsize--, x++, p++) {
  265.           Pixel = *p;
  266.           if (Pixel) {
  267.             LCD_L0_SetPixelIndex(x, y, Pixel);
  268.           }
  269.         }
  270.       }
  271.       break;
  272.   }
  273. }
  274. #endif
  276. /*********************************************
  277. *
  278. *       Draw Bitmap 16 BPP
  279. *
  280. **********************************************
  281. */
  283. #if (LCD_BITSPERPIXEL > 8)
  284. static void  DrawBitLine16BPP(int x, int y, U16 const * p, int xsize, const LCD_PIXELINDEX * pTrans) {
  285.   LCD_PIXELINDEX pixel;
  286.   if ((GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) == 0) {
  287.     if (pTrans) {
  288.       for (; xsize > 0; xsize--, x++, p++) {
  289.         pixel = *p;
  290.         LCD_L0_SetPixelIndex(x, y, *(pTrans + pixel));
  291.       }
  292.     } else {
  293.       for (;xsize > 0; xsize--, x++, p++) {
  294.         LCD_L0_SetPixelIndex(x, y, *p);
  295.       }
  296.     }
  297.   } else {
  298.     if (pTrans) {
  299.       for (; xsize > 0; xsize--, x++, p++) {
  300.         pixel = *p;
  301.         if (pixel) {
  302.           LCD_L0_SetPixelIndex(x, y, *(pTrans + pixel));
  303.         }
  304.       }
  305.     } else {
  306.       for (; xsize > 0; xsize--, x++, p++) {
  307.         pixel = *p;
  308.         if (pixel) {
  309.           LCD_L0_SetPixelIndex(x, y, pixel);
  310.         }
  311.       }
  312.     }
  313.   }
  314. }
  315. #endif
  317. /*********************************************************************
  318. *
  319. *       Exported functions
  320. *
  321. **********************************************************************
  322. */
  324. /*********************************************
  325. *
  326. *       LCD_L0_SetPixelIndex
  327. *
  328. **********************************************
  329. Purpose:
  330.   Sets the index of the given pixel. The upper layers of emWin
  331.   calling this routine make sure that the coordinates are in range, so
  332.   that no check on the parameters needs to be performed.
  333. */
  334. void LCD_L0_SetPixelIndex(int x, int y, int PixelIndex) 
  335. {
  336. #if 0
  337. U32 tempC1,tempC2;
  338.     tempC1 = (PixelIndex & 0xff0000)<<3;
  339.     tempC2 = (PixelIndex & 0x00ff00)<<2;
  340.     LCD_BUFFER[y][x>>1] = tempC1 | tempC2 | (PixelIndex << 3);
  341. #endif
  342. LCD_BUFFER[y][x] = PixelIndex;
  343. }
  346. /*********************************************
  347. *
  348. *       LCD_L0_GetPixelIndex
  349. *
  350. **********************************************
  351. Purpose:
  352.   Returns the index of the given pixel. The upper layers of emWin
  353.   calling this routine make sure that the coordinates are in range, so
  354.   that no check on the parameters needs to be performed.
  355. */
  357. unsigned int LCD_L0_GetPixelIndex(int x, int y) 
  358. {
  359. #if 0
  360. unsigned int tempC,tempC1,tempC2;
  361.     tempC1 = (LCD_BUFFER[y][x>>1] & 0xff0000)>>3;
  362.     tempC2 = (LCD_BUFFER[y][x>>1] & 0x00ff00)>>2;
  363.     tempC =  tempC1 | tempC2 | ((LCD_BUFFER[y][x>>1] & 0x0000ff)>>3);
  364.   return( tempC );
  365. #endif
  366. return LCD_BUFFER[y][x];
  368. }
  370. /*********************************************
  371. *
  372. *       LCD_L0_XorPixel
  373. *
  374. **********************************************
  375. */
  377. void LCD_L0_XorPixel(int x, int y) {
  378.   LCD_PIXELINDEX PixelIndex = LCD_L0_GetPixelIndex(x, y);
  379.   LCD_L0_SetPixelIndex(x, y, LCD_NUM_COLORS - PixelIndex - 1);
  380. }
  382. /*********************************************
  383. *
  384. *       LCD_L0_DrawHLine
  385. *
  386. **********************************************
  387. */
  389. void LCD_L0_DrawHLine  (int x0, int y,  int x1) {
  390.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR)
  391.   {
  392.     for (; x0 <= x1; x0++) 
  393. {
  394.       LCD_L0_XorPixel(x0, y);
  395.     }
  397.   } 
  398.   else
  399.   {
  400.     for (; x0 <= x1; x0++) 
  401. {
  403.        LCD_L0_SetPixelIndex(x0, y, LCD_COLORINDEX);
  404.     }
  405.   }
  406. }
  408. /*********************************************
  409. *
  410. *       LCD_L0_DrawVLine
  411. *
  412. **********************************************
  413. */
  415. void LCD_L0_DrawVLine  (int x, int y0,  int y1) {
  416.   if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
  417.     for (; y0 <= y1; y0++) {
  418.       LCD_L0_XorPixel(x, y0);
  419.     }
  420.   } else {
  421.     for (; y0 <= y1; y0++) {
  422.       LCD_L0_SetPixelIndex(x, y0, LCD_COLORINDEX);
  423.     }
  424.   }
  425. }
  427. /*********************************************
  428. *
  429. *       LCD_L0_FillRect
  430. *
  431. **********************************************
  432. */
  434. void LCD_L0_FillRect(int x0, int y0, int x1, int y1) {
  437.   for (; y0 <= y1; y0++) {
  439.     LCD_L0_DrawHLine(x0, y0, x1);
  441.   }
  443. }
  445. /*********************************************
  446. *
  447. *       LCD_L0_DrawBitmap
  448. *
  449. **********************************************
  450. */
  452. void LCD_L0_DrawBitmap(int x0, int y0,
  453.                        int xsize, int ysize,
  454.                        int BitsPerPixel, 
  455.                        int BytesPerLine,
  456.                        const U8* pData, int Diff,
  457.                        const LCD_PIXELINDEX* pTrans)
  458. {
  459.   int i;
  460.   /* Use _DrawBitLineXBPP */
  461.   for (i=0; i<ysize; i++) {
  462.     switch (BitsPerPixel) {
  463.     case 1:
  464.       _DrawBitLine1BPP(x0, i + y0, pData, Diff, xsize, pTrans);
  465.       break;
  466.       case 2:
  467.         _DrawBitLine2BPP(x0, i + y0, pData, Diff, xsize, pTrans);
  468.         break;
  469.       case 4:
  470.         _DrawBitLine4BPP(x0, i + y0, pData, Diff, xsize, pTrans);
  471.         break;
  472.       case 8:
  473.         _DrawBitLine8BPP(x0, i + y0, pData, xsize, pTrans);
  474.         break;
  475.       case 16:
  476.         DrawBitLine16BPP(x0, i + y0, (const U16 *)pData, xsize, pTrans);
  477.         break;
  478.     }
  479.     pData += BytesPerLine;
  480.   }
  481. }
  483. /*********************************************
  484. *
  485. *       LCD_L0_SetOrg
  486. *
  487. **********************************************
  488. */
  490. void LCD_L0_SetOrg(int x, int y) {
  491.   GUI_USE_PARA(x);
  492.   GUI_USE_PARA(y);
  493. }
  495. /*********************************************
  496. *
  497. *       LCD_On / LCD_Off
  498. *
  499. **********************************************
  500. */
  502. void LCD_On (void) 
  503. {
  506. }
  509. void LCD_Off (void) 
  510. {
  513. }
  515. /*********************************************
  516. *
  517. *       LCD_L0_Init
  518. *
  519. **********************************************
  520. Purpose:
  521.   Initialises the LCD-controller.
  522. */
  523. #if 0
  524. int  LCD_L0_Init(void) 
  525. {
  526. U16 mode = MODE_TFT_16BIT_240320;
  527.    Lcd_Port_Init();
  528. Lcd_Init(mode);
  529. Glib_Init(mode);
  530. Select_Tcon();
  531. Lcd_PowerEnable(0, 1);
  532. Lcd_EnvidOnOff(1);
  533. Glib_ClearScr(0, mode);
  534.   return 0;
  535. }
  536. #endif
  537. void  LCD_L0_ReInit(void) {
  538.   LCD_INIT_CONTROLLER();                     /* macro defined in config */
  539. }
  540. /*********************************************
  541. *
  542. *       LCD_L0_SetLUTEntry
  543. *
  544. **********************************************
  545. */
  547. void LCD_L0_SetLUTEntry(U8 Pos, LCD_COLOR Color) {
  548.   GUI_USE_PARA(Pos);
  549.   GUI_USE_PARA(Color);
  550. }
  552. ///////from here it is myself define
  554. /**************************************************************
  555. 320×240 16Bpp TFT LCD功能模块初始化
  556. **************************************************************/
  558. void Lcd_Init(void )
  559. {
  560.     rGPCUP  = 0x00000000;
  561.  rGPCCON = 0xaaaa02a9; 
  562.  
  563. //    rGPDUP=0xffffffff; // Disable Pull-up register
  564.      rGPDUP  = 0x00000000;
  565.    rGPDCON=0xaaaaaaaa; //Initialize VD[15:8]
  567. rLCDCON1=(CLKVAL_TFT<<8)|(MVAL_USED<<7)|(3<<5)|(12<<1)|0;
  568.      // TFT LCD panel,16bpp TFT,ENVID=off
  569. rLCDCON2=(VBPD<<24)|(LINEVAL_TFT<<14)|(VFPD<<6)|(VSPW);
  570. rLCDCON3=(HBPD<<19)|(HOZVAL_TFT<<8)|(HFPD);
  571. rLCDCON4=(MVAL<<8)|(HSPW);
  572. #if LCD_TYPE==LCD_TYPE_VGA1024x768
  573. rLCDCON5=(1<<11)|(0<<9)|(0<<8)|(0<<3)|(1<<0);
  574. #else
  575.     rLCDCON5 = (1<<11) | (1<<10) | (1<<9) | (1<<8) | (0<<7) | (0<<6)
  576.              | (1<<3)  |(BSWP<<1) | (HWSWP);
  577.              //5:6:5 VCLK posedge BSWP=0,HWSWP=1;
  578. #endif             
  580. rLCDSADDR1=(((U32)LCD_BUFFER>>22)<<21)|M5D((U32)LCD_BUFFER>>1);
  581. rLCDSADDR2=M5D( ((U32)LCD_BUFFER+(SCR_XSIZE_TFT*LCD_TFT_YSIZE*2))>>1 );
  582. rLCDSADDR3=(((SCR_XSIZE_TFT-LCD_TFT_XSIZE)/1)<<11)|(LCD_TFT_XSIZE/1);
  583. rLCDINTMSK|=(3); // MASK LCD Sub Interrupt
  584.     rTCONSEL &= (~7) ;     // Disable LPC3480
  585. rTPAL=0; // Disable Temp Palette
  586. }
  588. /**************************************************************
  589. LCD视频和控制信号输出或者停止，1开启视频输出
  590. **************************************************************/
  591. void Lcd_EnvidOnOff(int onoff)
  592. {
  593.     if(onoff==1)
  594. rLCDCON1|=1; // ENVID=ON
  595.     else
  596. rLCDCON1 =rLCDCON1 & 0x3fffe; // ENVID Off
  597. }
  599. /**************************************************************
  600. 320×240 16Bpp TFT LCD 电源控制引脚使能
  601. **************************************************************/
  602. void Lcd_PowerEnable(int invpwren,int pwren)
  603. {
  604.     //GPG4 is setted as LCD_PWREN
  605.     rGPGUP=rGPGUP&(~(1<<4))|(1<<4); // Pull-up disable
  606.     rGPGCON=rGPGCON&(~(3<<8))|(3<<8); //GPG4=LCD_PWREN
  607.     rGPGDAT = rGPGDAT | (1<<4) ;
  608. // invpwren=pwren;
  609.     //Enable LCD POWER ENABLE Function
  610.     rLCDCON5=rLCDCON5&(~(1<<3))|(pwren<<3);   // PWREN
  611.     rLCDCON5=rLCDCON5&(~(1<<5))|(invpwren<<5);   // INVPWREN
  612. }
  613. /**************************************************************
  614. 240×320 16Bpp TFT LCD全屏填充特定颜色单元或清屏
  615. **************************************************************/
  616. void Lcd_ClearScr( U16 c)
  617. {
  618. unsigned int x,y ;
  620.     for( y = 0 ; y < SCR_YSIZE_TFT_240320 ; y++ )
  621.     {
  622.      for( x = 0 ; x < SCR_XSIZE_TFT_240320 ; x++ )
  623.      {
  624. LCD_BUFFER[y][x] = c ;
  625.      }
  626.     }
  627. }
  629. int LCD_L0_Init(void)
  630. {
  631.     Lcd_Init();
  632. Lcd_PowerEnable(0, 1);
  633.     Lcd_EnvidOnOff(1); //turn on vedio
  634.     Lcd_ClearScr( (0x00<<11) | (0x00<<5) | (0x00) );  
  635. return 0;
  636. }