eGUI alias D4D  Release 3.0
Reference Manual
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
d4dlcd_ili9341.c
Go to the documentation of this file.
1 /**************************************************************************
2 *
3 * Copyright 2014 by Petr Gargulak. eGUI Community.
4 * Copyright 2009-2013 by Petr Gargulak. Freescale Semiconductor, Inc.
5 *
6 ***************************************************************************
7 * This program is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License Version 3
9 * or later (the "LGPL").
10 *
11 * As a special exception, the copyright holders of the eGUI project give you
12 * permission to link the eGUI sources with independent modules to produce an
13 * executable, regardless of the license terms of these independent modules,
14 * and to copy and distribute the resulting executable under terms of your
15 * choice, provided that you also meet, for each linked independent module,
16 * the terms and conditions of the license of that module.
17 * An independent module is a module which is not derived from or based
18 * on this library.
19 * If you modify the eGUI sources, you may extend this exception
20 * to your version of the eGUI sources, but you are not obligated
21 * to do so. If you do not wish to do so, delete this
22 * exception statement from your version.
23 *
24 * This program is distributed in the hope that it will be useful,
25 * but WITHOUT ANY WARRANTY; without even the implied warranty of
26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
27 *
28 * You should have received a copy of the GNU General Public License
29 * and the GNU Lesser General Public License along with this program.
30 * If not, see <http://www.gnu.org/licenses/>.
31 *
32 ***************************************************************************/
46 #include "d4d.h" // include of all public items (types, function etc) of D4D driver
47 #include "common_files/d4d_lldapi.h" // include non public low level driver interface header file (types, function prototypes, enums etc. )
48 #include "common_files/d4d_private.h" // include the private header file that contains perprocessor macros as D4D_MK_STR
49 
50 /******************************************************************************
51 * D4D LCD Driver setting constants
52 *
53 */
59 #define d4dlcd_ili9341_ID 1
60 
63 // copilation enable preprocessor condition
64 // the string d4dlcd_template_ID must be replaced by define created one line up
65 #if (D4D_MK_STR(D4D_LLD_LCD) == d4dlcd_ili9341_ID)
66 // #if (D4D_LLD_LCD == d4dlcd_template_ID)
67  // include of low level driver heaser file
68  // it will be included into wole project only in case that this driver is selected in main D4D configuration file
69  #include "low_level_drivers\LCD\lcd_controllers_drivers\ILI9341\d4dlcd_ili9341.h"
70  #include "low_level_drivers\LCD\lcd_hw_interface\common_drivers\d4dlcdhw_common.h"
71  /******************************************************************************
72  * Macros
73  ******************************************************************************/
74 
75  /******************************************************************************
76  * Internal function prototypes
77  ******************************************************************************/
78 
79  static unsigned char D4DLCD_Init_ILI9341(void);
80  static unsigned char D4DLCD_SetWindow_ILI9341(unsigned short x1, unsigned short y1, unsigned short x2, unsigned short y2);
81  static unsigned char D4DLCD_SetOrientation_ILI9341(D4DLCD_ORIENTATION new_orientation);
82  static void D4DLCD_Send_PixelColor_ILI9341(D4D_COLOR color) ;
83  static D4D_COLOR D4DLCD_Get_PixelColor_ILI9341(void);
84  static void D4DLCD_Flush_ILI9341(D4DLCD_FLUSH_MODE mode);
85  static void D4DLCD_Delay_ms_ILI9341(unsigned short period);
86  static unsigned char D4DLCD_DeInit_ILI9341(void);
87 
88  /**************************************************************/
94  /******************************************************************************
95  * D4D LCD Driver setting variables
96  *
97  */
104  const D4DLCD_FUNCTIONS d4dlcd_ili9341 =
105  {
106  D4DLCD_Init_ILI9341,
107  D4DLCD_SetWindow_ILI9341,
108  D4DLCD_SetOrientation_ILI9341,
109  D4DLCD_Send_PixelColor_ILI9341,
110  D4DLCD_Get_PixelColor_ILI9341,
111  D4DLCD_Flush_ILI9341,
112  D4DLCD_Delay_ms_ILI9341,
113  D4DLCD_DeInit_ILI9341,
114  };
116  /**************************************************************/
121  static D4DLCD_ORIENTATION d4dlcd_orientation = Portrait;
122  /**************************************************************/
127  // sends Command/Data sequence word (16 bit) or array with words - first 1 command, then 1 x data
128  static void D4DLCD_Command_Data(const unsigned short data[], unsigned short count)
129  {
130  int i;
131 
132  for (i=0; i<count; i+=2)
133  {
134  (void)D4D_LLD_LCD_HW.D4DLCDHW_SendCmdWord(data[i]);
135  (void)D4D_LLD_LCD_HW.D4DLCDHW_SendDataWord(data[i+1]);
136  }
137  }
138  /******************************************************************************
139  * Begin of D4D_LCD public functions
140  */
144  /**************************************************************************/
149  static unsigned char D4DLCD_Init_ILI9341(void)
150  { unsigned short data[10] = {0};
151  const unsigned short init_data[] =
152  {
153  0x0001, //Software Reset
154 
155  0x00CF, 0x0000, 0x00C1, 0x0030, //CMD Power Control_B
156 
157  0x00ED, 0x0067, 0x0003, 0x0012, 0x0081,//CMD POWER ON SEQ Control
158 
159  0x00E8, 0x0085, 0x0000, 0x0078, //CMD Driver Timing Control A
160 
161  0x00CB, 0x0039, 0x002C, 0x0000, 0x0034, 0x0002,//CMD Power Control A
162 
163  0x00F7, 0x0020, //CMD Pump Ratio Control
164 
165  0x00EA, 0x0000, 0x0000, //CMD Driver Timing Control B
166 
168  0x00C0, 0x0023, //Power control VRH[5:0] //4.1V
169 
170  0x00C1, 0x0010, //Power control SAP[2:0];BT[3:0]
171 
172  0x00C5, 0x002B, 0x002B,//VCOM control VMH =4.275V VML = -1.0V
173 
174  0x00C7, 0x0090,//VCOM control2 VMH = -48 VML = -48
175 
176  0x0036, 0x0048, // Memory Access Control BGR
177 
178  0x003A, 0x0005,//16 Bit/Pixel
179 
180  0x00B1, 0x0000, 0x001B,//Frame Rate Control DIVA = FOSC Frame Rate = 83Hz
181 
182  0x00B6, 0x000A, 0x0002,//Display Function Control
183 
184  0x00F6, 0x0001, 0x0030,//Interface Control
185 
186  0x00F2, 0x0002, //3Gamma Function Disable
187 
188  0x0026, 0x0001, //Gamma curve select
189 
190  0x00E0, 0x000F, 0x0026, 0x0022, 0x000A, 0x0010, 0x000A, 0x004C, 0x00CA, 0x0036, //Set Gamma 1
191  0x0000, 0x0015, 0x0000, 0x0010, 0x0010, 0x0000,
192 
193  0x00E1, 0x0000, 0x0019, 0x001B, 0x0005, 0x000F, 0x0005, 0x0033, 0x0035, 0x0049, //Set Gamma 2
194  0x000F, 0x001F, 0x000F, 0x003F, 0x003F, 0x000F,
195 
196  0x0011, //Exit sleep
197 
198  0x0029, //Display on
199 
200  } ;
201 
202  if(D4D_LLD_LCD_HW.D4DLCDHW_Init == NULL)
203  return 0;
204  if(D4D_LLD_LCD_HW.D4DLCDHW_SendDataWord == NULL)
205  return 0;
206  if(D4D_LLD_LCD_HW.D4DLCDHW_SendCmdWord == NULL)
207  return 0;
208  if(D4D_LLD_LCD_HW.D4DLCDHW_ReadDataWord == NULL)
209  return 0;
210  if(D4D_LLD_LCD_HW.D4DLCDHW_ReadCmdWord == NULL)
211  return 0;
212  if(D4D_LLD_LCD_HW.D4DLCDHW_PinCtl == NULL)
213  return 0;
214  if(D4D_LLD_LCD_HW.D4DLCDHW_FlushBuffer == NULL)
215  return 0;
216  if(D4D_LLD_LCD_HW.D4DLCDHW_DeInit == NULL)
217  return 0;
218 
219 
220  if(!D4D_LLD_LCD_HW.D4DLCDHW_Init())
221  return 0;
222 
223  (void)D4D_LLD_LCD_HW.D4DLCDHW_PinCtl(D4DLCD_BACKLIGHT_PIN, D4DHW_PIN_SET_1);
224  (void)D4D_LLD_LCD_HW.D4DLCDHW_PinCtl(D4DLCD_BACKLIGHT_PIN, D4DHW_PIN_OUT);
225 
226  (void)D4D_LLD_LCD_HW.D4DLCDHW_PinCtl(D4DLCD_RESET_PIN, D4DHW_PIN_SET_0);
227  (void)D4D_LLD_LCD_HW.D4DLCDHW_PinCtl(D4DLCD_RESET_PIN, D4DHW_PIN_OUT);
228 
229  D4DLCD_Delay_ms_Common(300);
230  (void)D4D_LLD_LCD_HW.D4DLCDHW_PinCtl(D4DLCD_RESET_PIN, D4DHW_PIN_SET_1); D4DLCD_Delay_ms_Common(200);
231  (void)D4D_LLD_LCD_HW.D4DLCDHW_PinCtl(D4DLCD_RESET_PIN, D4DHW_PIN_SET_0); D4DLCD_Delay_ms_Common(200);
232  (void)D4D_LLD_LCD_HW.D4DLCDHW_PinCtl(D4DLCD_RESET_PIN, D4DHW_PIN_SET_1); D4DLCD_Delay_ms_Common(200);
233 
234 
235  //Lets try to read
236  (void)D4D_LLD_LCD_HW.D4DLCDHW_SendCmdWord(0x0009);//Read Display Status
237  data[0] = D4D_LLD_LCD_HW.D4DLCDHW_ReadCmdWord();//Dummy
238  data[1] = D4D_LLD_LCD_HW.D4DLCDHW_ReadCmdWord();//0x0000
239  data[2] = D4D_LLD_LCD_HW.D4DLCDHW_ReadCmdWord();//Return 0x0061
240  data[3] = D4D_LLD_LCD_HW.D4DLCDHW_ReadCmdWord();//0x0000
241  data[4] = D4D_LLD_LCD_HW.D4DLCDHW_ReadCmdWord();//0x0000
242 
243 
244 
245 
246 
247 
248  D4DLCD_Command_Data(&init_data[0], 1); D4DLCD_Delay_ms_Common(15);//Software Reset
249  D4DLCD_Command_Data(&init_data[1], 4); D4DLCD_Delay_ms_Common(15);//CMD Power Control_B
250  D4DLCD_Command_Data(&init_data[5], 5); D4DLCD_Delay_ms_Common(150);//CMD POWER ON SEQ Control
251  D4DLCD_Command_Data(&init_data[10], 4); D4DLCD_Delay_ms_Common(20);//CMD Driver Timing Control A
252  D4DLCD_Command_Data(&init_data[14], 6); D4DLCD_Delay_ms_Common(20);//CMD Power Control A
253  D4DLCD_Command_Data(&init_data[20], 2); D4DLCD_Delay_ms_Common(31);//CMD Pump Ratio Control
254  D4DLCD_Command_Data(&init_data[22], 3); D4DLCD_Delay_ms_Common(31);//CMD Driver Timing Control B
256  D4DLCD_Command_Data(&init_data[25], 2); D4DLCD_Delay_ms_Common(31);//Power control VRH[5:0] //4.1V
257  D4DLCD_Command_Data(&init_data[27], 2); D4DLCD_Delay_ms_Common(31);//Power control SAP[2:0];BT[3:0]
258  D4DLCD_Command_Data(&init_data[29], 3); D4DLCD_Delay_ms_Common(31);//VCOM control VMH =4.275V VML = -1.0V
259  D4DLCD_Command_Data(&init_data[32], 2); D4DLCD_Delay_ms_Common(31);//VCOM control2 VMH = -48 VML = -48
260  D4DLCD_Command_Data(&init_data[34], 2); D4DLCD_Delay_ms_Common(31);// Memory Access Control BGR
261  D4DLCD_Command_Data(&init_data[36], 2); D4DLCD_Delay_ms_Common(31);//16 Bit/Pixel
262  D4DLCD_Command_Data(&init_data[38], 3); D4DLCD_Delay_ms_Common(31);//Frame Rate Control DIVA = FOSC Frame Rate = 83Hz
263  D4DLCD_Command_Data(&init_data[41], 3); D4DLCD_Delay_ms_Common(31);//Display Function Control
264  D4DLCD_Command_Data(&init_data[44], 3); D4DLCD_Delay_ms_Common(31);//Interface Control
265  D4DLCD_Command_Data(&init_data[47], 2); D4DLCD_Delay_ms_Common(31);//3Gamma Function Disable
266  D4DLCD_Command_Data(&init_data[49], 2); D4DLCD_Delay_ms_Common(31);//Gamma curve select
267  D4DLCD_Command_Data(&init_data[51], 16); D4DLCD_Delay_ms_Common(31);//Set Gamma 1
268  D4DLCD_Command_Data(&init_data[67], 16); D4DLCD_Delay_ms_Common(31);//Set Gamma 2
269  D4DLCD_Command_Data(&init_data[83], 1); D4DLCD_Delay_ms_Common(31);//Exit sleep
270  D4DLCD_Command_Data(&init_data[84], 1); D4DLCD_Delay_ms_Common(31);//Display on
271 
272  (void)D4D_LLD_LCD_HW.D4DLCDHW_SendCmdWord(0x000A);//Read Display Power Mode
273  data[0] = D4D_LLD_LCD_HW.D4DLCDHW_ReadCmdWord();//Dummy
274  data[1] = D4D_LLD_LCD_HW.D4DLCDHW_ReadCmdWord();//Return 0x009C
275 
276  (void)D4D_LLD_LCD_HW.D4DLCDHW_SendCmdWord(0x000B);//Read Display MADCTL
277  data[0] = D4D_LLD_LCD_HW.D4DLCDHW_ReadCmdWord();//Dummy
278  data[1] = D4D_LLD_LCD_HW.D4DLCDHW_ReadCmdWord();//Return 0x0048
279 
280  (void)D4D_LLD_LCD_HW.D4DLCDHW_SendCmdWord(0x000C);//Read Display Pixel Format
281  data[0] = D4D_LLD_LCD_HW.D4DLCDHW_ReadCmdWord();//Dummy
282  data[1] = D4D_LLD_LCD_HW.D4DLCDHW_ReadCmdWord();//Return 0x0005 //16 Bits/Pixel
283 
284  (void)D4D_LLD_LCD_HW.D4DLCDHW_SendCmdWord(0x000D);//Read Display Image Format
285  data[0] = D4D_LLD_LCD_HW.D4DLCDHW_ReadCmdWord();//Dummy
286  data[1] = D4D_LLD_LCD_HW.D4DLCDHW_ReadCmdWord();//Return 0x0000//Gamma Curve 1
287 
288 
289  (void)D4D_LLD_LCD_HW.D4DLCDHW_SendCmdWord(0x000F);//Read Display Self Diagnostic
290  data[0] = D4D_LLD_LCD_HW.D4DLCDHW_ReadCmdWord();//Dummy
291  data[1] = D4D_LLD_LCD_HW.D4DLCDHW_ReadCmdWord();//Return 0x00C0
292 
293  return 1;
294  }
295 
296  /**************************************************************************/
301  static unsigned char D4DLCD_DeInit_ILI9341(void)
302  {
303 
304  }
305 
306  /**************************************************************************/
315  static unsigned char D4DLCD_SetWindow_ILI9341(unsigned short x1, unsigned short y1, unsigned short x2, unsigned short y2)
316  {
317  unsigned short x1_x2;
318  unsigned short Addr1, Addr2;
319 /*
320  switch (d4dlcd_orientation)
321  {
322  default:
323  // Invalid! Fall through to portrait mode
324  case Portrait:
325  Addr1 = x1;
326  Addr2 = y1;
327  x1_x2 = (unsigned short)((x2<<8) + x1); // pack X-Values into one word
328  break;
329 
330  case Portrait180:
331  Addr1 = (unsigned short)(D4D_SCREEN_SIZE_SHORTER_SIDE - 1 - x1);
332  Addr2 = (unsigned short)(D4D_SCREEN_SIZE_LONGER_SIDE - 1 - y1);
333  x1_x2 = (unsigned short)((Addr1<<8) + (D4D_SCREEN_SIZE_SHORTER_SIDE - 1 - x2)); // pack X-Values into one word
334  y1 = (unsigned short)(D4D_SCREEN_SIZE_LONGER_SIDE - 1 - y2);
335  y2 = Addr2;
336  break;
337 
338  case Landscape:
339  Addr1 = (unsigned short)(D4D_SCREEN_SIZE_SHORTER_SIDE - 1 - y1);
340  Addr2 = x1;
341  x1_x2 = (unsigned short)((Addr1<<8) + (D4D_SCREEN_SIZE_SHORTER_SIDE - 1 - y2)); // pack X-Values into one word
342  y1 = x1;
343  y2 = x2;
344  break;
345 
346  case Landscape180:
347  Addr1 = y1;
348  Addr2 = (unsigned short)(D4D_SCREEN_SIZE_LONGER_SIDE - 1 - x1); // pack X-Values into one word
349  x1_x2 = (unsigned short)((y2<<8) + y1);
350  y1 = (unsigned short)(D4D_SCREEN_SIZE_LONGER_SIDE - 1 - x2);
351  y2 = Addr2;
352  break;
353 
354  }
355  */
356 
357  if (x2 >= MAX_X)
358  {
359  x2 = MAX_X - 1;
360  }
361  if (x1 >= MAX_X)
362  {
363  x1 = MAX_X - 1;
364  }
365  if (y2 >= MAX_Y)
366  {
367  y2 = MAX_Y - 1;
368  }
369  if (y1 >= MAX_Y)
370  {
371  y1 = MAX_Y - 1;
372  }
373 
374  (void)D4D_LLD_LCD_HW.D4DLCDHW_SendCmdWord(0x002A);//Column Address Set
375  (void)D4D_LLD_LCD_HW.D4DLCDHW_SendDataWord((unsigned short)((x1 >> 8) & 0x00ff));
376  (void)D4D_LLD_LCD_HW.D4DLCDHW_SendDataWord((unsigned short)(x1 & 0x00ff));
377  (void)D4D_LLD_LCD_HW.D4DLCDHW_SendDataWord((unsigned short)((x2 >> 8) & 0x00ff));
378  (void)D4D_LLD_LCD_HW.D4DLCDHW_SendDataWord((unsigned short)(x2 & 0x00ff));
379 
380 
381  (void)D4D_LLD_LCD_HW.D4DLCDHW_SendCmdWord(0x002B);//Page Address Set
382  (void)D4D_LLD_LCD_HW.D4DLCDHW_SendDataWord((unsigned short)((y1 >> 8) & 0x00ff));
383  (void)D4D_LLD_LCD_HW.D4DLCDHW_SendDataWord((unsigned short)(y1 & 0x00ff));
384  (void)D4D_LLD_LCD_HW.D4DLCDHW_SendDataWord((unsigned short)((y2 >> 8) & 0x00ff));
385  (void)D4D_LLD_LCD_HW.D4DLCDHW_SendDataWord((unsigned short)(y2 & 0x00ff));
386 
387 
388  (void)D4D_LLD_LCD_HW.D4DLCDHW_SendCmdWord(0x002C);//Memory Write
389 
390 
391 
392  }
393 
394  /**************************************************************************/
400  static unsigned char D4DLCD_SetOrientation_ILI9341(D4DLCD_ORIENTATION new_orientation)
401  {
402  unsigned short LCD_EntryMode = 0;
403 
404  d4dlcd_orientation = new_orientation;
405 
406  switch (d4dlcd_orientation)
407  {
408  default: // Invalid! Fall through to portrait mode
409  case Portrait:
410  LCD_EntryMode = 0x60b0; break; // &B110000010110000
411  case Portrait180:
412  LCD_EntryMode = 0x6080; break; // &B110000010000000
413  case Landscape:
414  LCD_EntryMode = 0x60a8; break; // &B110000010101000
415  case Landscape180:
416  LCD_EntryMode = 0x6098; break; // &B110000010011000
417  }
418  //(void)D4D_LLD_LCD_HW.D4DLCDHW_SendCmdWord(0x0011);
419  //(void)D4D_LLD_LCD_HW.D4DLCDHW_SendDataWord(LCD_EntryMode);
420 
421  (void)D4DLCD_SetWindow_ILI9341(0, 0, 1, 1);
422 
423  return 1;
424  }
425 
426  /**************************************************************************/
433  static void D4DLCD_Send_PixelColor_ILI9341(D4D_COLOR value)
434  { //int count = 0;
435  // unsigned short data[10] = {0};
436  #ifdef D4D_COLOR_TRANSPARENT
437  if(value == D4D_COLOR_TRANSPARENT)
438  D4D_LLD_LCD_HW.D4DLCDHW_ReadDataWord();
439  else
440  #endif
441  {
442  #if D4D_COLOR_SYSTEM != D4D_COLOR_SYSTEM_RGB565
443  Word color = D4D_COLOR_RGB565(D4D_COLOR_GET_R(value), D4D_COLOR_GET_G(value), D4D_COLOR_GET_B(value));
444  D4D_LLD_LCD_HW.D4DLCDHW_SendDataWord(color);
445  #else
446  D4D_LLD_LCD_HW.D4DLCDHW_SendDataWord((unsigned short)value);
447 // (void)D4D_LLD_LCD_HW.D4DLCDHW_SendCmdWord(0x002E);//Memory Read
448 // data[0] = D4D_LLD_LCD_HW.D4DLCDHW_ReadCmdWord();//Dummy
449  /*if (value != 0 && value != 65504)
450  count++;
451 
452  if(count > 10000) count = 0;*/
453  #endif
454 
455  }
456  }
457 
458  /**************************************************************************/
464  static D4D_COLOR D4DLCD_Get_PixelColor_ILI9341(void)
465  {
466  #if D4D_COLOR_SYSTEM != D4D_COLOR_SYSTEM_RGB565
467  Word color = D4D_LLD_LCD_HW.D4DLCDHW_ReadDataWord();
468  return D4D_COLOR_RGB(D4D_COLOR565_GET_R(color), D4D_COLOR565_GET_G(color), D4D_COLOR565_GET_B(color));
469  #else
470  return D4D_LLD_LCD_HW.D4DLCDHW_ReadDataWord();
471  #endif
472  }
473 
474  /**************************************************************************/
481  static void D4DLCD_Flush_ILI9341(D4DLCD_FLUSH_MODE mode)
482  {
483  D4D_LLD_LCD_HW.D4DLCDHW_FlushBuffer(mode);
484  }
485 
486  //-----------------------------------------------------------------------------
487  // FUNCTION: D4DLCD_Delay_ms_Template
488  // SCOPE: Low Level Driver API function
489  // DESCRIPTION: For do some small delays in ms
490  //
491  // PARAMETERS: period - count of ms
492  //
493  // RETURNS: none
494  //-----------------------------------------------------------------------------
495  /**************************************************************************/
501  static void D4DLCD_Delay_ms_ILI9341(unsigned short period)
502  {
503 
504  }
505 
508 #endif //(D4D_MK_STR(D4D_LLD_LCD) == d4dlcd_ili9341_ID)
D4D_COLOR_RGB565
#define D4D_COLOR_RGB565(R, G, B)
The macro create the color from the color component Red/Green/Blue to 16-bit RGB565 format (the input...
Definition: d4d_scheme.h:301
d4dlcd_ili9341.h
D4D driver - ILI9341 lcd driver function header file.
D4D_COLOR_GET_B
#define D4D_COLOR_GET_B(color)
Definition: d4d_scheme.h:438
D4DLCD_FUNCTIONS_S
D4D low level standard LCD interface API structure.
Definition: d4d_lldapi.h:147
D4D_COLOR_RGB
#define D4D_COLOR_RGB(R, G, B)
Definition: d4d_scheme.h:434
Landscape180
Orientation LandScape up side down.
Definition: d4d_lldapi.h:69
D4D_LLD_LCD_HW
#define D4D_LLD_LCD_HW
Definition: d4d_types.h:76
D4D_COLOR565_GET_B
#define D4D_COLOR565_GET_B(color)
The macro gets the Blue component from 16-bit standard format to 8-bit component format.
Definition: d4d_scheme.h:299
d4d.h
D4D Driver main header file.
Landscape
Orientation LandScape.
Definition: d4d_lldapi.h:68
D4DLCD_FLUSH_MODE
D4DLCD_FLUSH_MODE
D4D low level eGUI flush screen types enumeration.
Definition: d4d_lldapi.h:136
d4d_private.h
D4D Driver private header file.
Portrait180
Orientation Portrait up side down.
Definition: d4d_lldapi.h:67
D4DLCD_ORIENTATION
D4DLCD_ORIENTATION
D4D low level screen orientation enumeration type.
Definition: d4d_lldapi.h:64
D4DHW_PIN_OUT
Switch pin to output mode.
Definition: d4d_lldapi.h:77
NULL
#define NULL
Type definition of null pointer.
Definition: d4d_types.h:184
D4DHW_PIN_SET_1
Set pin output register to logic 1.
Definition: d4d_lldapi.h:80
D4DLCD_BACKLIGHT_PIN
LCD device backlight enable signal.
Definition: d4d_lldapi.h:99
MAX_Y
#define MAX_Y
Definition: d4dlcd_ili9341.h:62
D4D_COLOR565_GET_R
#define D4D_COLOR565_GET_R(color)
The macro gets the Red component from 16-bit standard format to 8-bit component format.
Definition: d4d_scheme.h:297
D4D_COLOR_GET_G
#define D4D_COLOR_GET_G(color)
Definition: d4d_scheme.h:437
D4DHW_PIN_SET_0
Set pin output register to logic 0.
Definition: d4d_lldapi.h:79
D4D_COLOR565_GET_G
#define D4D_COLOR565_GET_G(color)
The macro gets the Green component from 16-bit standard format to 8-bit component format...
Definition: d4d_scheme.h:298
d4dlcdhw_common.h
D4D driver - common low level driver header file.
D4DLCD_Delay_ms_Common
void D4DLCD_Delay_ms_Common(unsigned short period)
Definition: d4dlcdhw_common.c:259
Portrait
Orientation Portrait.
Definition: d4d_lldapi.h:66
d4d_lldapi.h
D4D driver - resistive touch screen driver function header file.
MAX_X
#define MAX_X
Definition: d4dlcd_ili9341.h:61
D4D_COLOR
LWord D4D_COLOR
Type definition of eGUI color variables.
Definition: d4d_types.h:262
Word
unsigned short Word
Type definition of Word (unsigned 16-bit).
Definition: d4d_types.h:159
D4DLCD_RESET_PIN
LCD device reset signal.
Definition: d4d_lldapi.h:98
D4D_COLOR_GET_R
#define D4D_COLOR_GET_R(color)
Definition: d4d_scheme.h:436