EFM32 Pearl Gecko Software Documentation  efm32pg1-doc-4.2.1
displayls013b7dh03.c
Go to the documentation of this file.
1 /**************************************************************************/
18 #include <stdint.h>
19 #include <stdbool.h>
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23 
24 #include "em_gpio.h"
25 
26 /* DISPLAY driver inclustions */
27 #include "displayconfigall.h"
28 #include "displaypal.h"
29 #include "displaybackend.h"
30 #include "displayls013b7dh03.h"
31 
34 /*******************************************************************************
35  ******************************** DEFINES ************************************
36  ******************************************************************************/
37 
38 /* LS013B7DH03 SPI commands */
39 #define LS013B7DH03_CMD_UPDATE (0x01)
40 #define LS013B7DH03_CMD_ALL_CLEAR (0x04)
41 
42 /* Frequency of LCD polarity inversion. */
43 #ifndef LS013B7DH03_POLARITY_INVERSION_FREQUENCY
44 #define LS013B7DH03_POLARITY_INVERSION_FREQUENCY (128)
45 #endif
46 
47 #ifdef USE_CONTROL_BYTES
48 #define LS013B7DH03_CONTROL_BYTES (2)
49 #else
50 #define LS013B7DH03_CONTROL_BYTES (0)
51 #endif
52 
53 #ifdef PIXEL_MATRIX_ALLOC_SUPPORT
54 
55  #ifdef USE_STATIC_PIXEL_MATRIX_POOL
56  /* Static pool has been chosen for pixelmatix allocation.
57  Disable the use of malloc for allocation of pixel matrices. */
58  #undef USE_MALLOC
59  #endif
60 
61  #ifdef USE_MALLOC
62  /* malloc has been chosen for pixelmatix allocation.
63  Disable the use of static pool for allocation of pixel matrices. */
64  #undef USE_STATIC_PIXEL_MATRIX_POOL
65  #endif
66 
67 #endif /* PIXEL_MATRIX_ALLOC_SUPPORT */
68 
69 
70 /*******************************************************************************
71  ********************************* TYPEDEFS **********************************
72  ******************************************************************************/
73 
74 #ifdef PIXEL_MATRIX_ALLOC_SUPPORT
75 #ifndef PIXEL_MATRIX_ALIGNMENT
76 typedef uint8_t PixelMatrixAlign_t;
77 #else
78  #if (1 == PIXEL_MATRIX_ALIGNMENT)
79  typedef uint8_t PixelMatrixAlign_t;
80  #elif (2 == PIXEL_MATRIX_ALIGNMENT)
81  typedef uint16_t PixelMatrixAlign_t;
82  #elif (4 == PIXEL_MATRIX_ALIGNMENT)
83  typedef uint32_t PixelMatrixAlign_t;
84  #else
85  #error Unsupported PIXEL_MATRIX_ALIGNMENT.
86  #endif
87 #endif
88 #endif
89 
90 
91 /*******************************************************************************
92  ******************************** STATICS ************************************
93  ******************************************************************************/
94 
95 /* Static variables: */
96 static uint8_t lcdPolarity = 0;
97 
98 #ifdef PIXEL_MATRIX_ALLOC_SUPPORT
99 #ifdef USE_STATIC_PIXEL_MATRIX_POOL
100 #define PIXEL_MATRIX_POOL_ELEMENTS \
101  (PIXEL_MATRIX_POOL_SIZE/sizeof(PixelMatrixAlign_t) + \
102  ((PIXEL_MATRIX_POOL_SIZE%sizeof(PixelMatrixAlign_t))? 1 : 0))
103 static PixelMatrixAlign_t pixelMatrixPoolBase[PIXEL_MATRIX_POOL_ELEMENTS];
104 static PixelMatrixAlign_t* pixelMatrixPool = pixelMatrixPoolBase;
105 #endif
106 #endif
107 
108 
109 /*******************************************************************************
110  ************************ STATIC FUNCTION PROTOTYPES ***********************
111  ******************************************************************************/
112 
113 static EMSTATUS DisplayEnable(DISPLAY_Device_t* device,
114  bool enable);
115 static EMSTATUS DisplayClear(void);
116 #ifndef POLARITY_INVERSION_EXTCOMIN_PAL_AUTO_TOGGLE
117 static EMSTATUS DisplayPolarityInverse (void);
118 #endif
119 
120 #ifdef PIXEL_MATRIX_ALLOC_SUPPORT
121 static EMSTATUS PixelMatrixAllocate( DISPLAY_Device_t* device,
122  unsigned int width,
123 #ifdef EMWIN_WORKAROUND
124  unsigned int userStride,
125 #endif
126  unsigned int height,
127  DISPLAY_PixelMatrix_t *pixelMatrix);
128 static EMSTATUS PixelMatrixFree( DISPLAY_Device_t* device,
129  DISPLAY_PixelMatrix_t pixelMatrix);
130 #endif
131 static EMSTATUS PixelMatrixDraw( DISPLAY_Device_t* device,
132  DISPLAY_PixelMatrix_t pixelMatrix,
133  unsigned int startColumn,
134  unsigned int width,
135 #ifdef EMWIN_WORKAROUND
136  unsigned int userStride,
137 #endif
138  unsigned int startRow,
139  unsigned int height );
140 static EMSTATUS PixelMatrixClear( DISPLAY_Device_t* device,
141  DISPLAY_PixelMatrix_t pixelMatrix,
142  unsigned int width,
143  unsigned int height);
144 static EMSTATUS DriverRefresh (DISPLAY_Device_t* device);
145 
146 
147 /*******************************************************************************
148  ************************** GLOBAL FUNCTIONS **************************
149  ******************************************************************************/
150 
151 /**************************************************************************/
156 EMSTATUS DISPLAY_Ls013b7dh03Init(void)
157 {
158  DISPLAY_Device_t display;
159  EMSTATUS status;
160 
161  /* Initialize the Platform Abstraction Layer (PAL) interface. */
162  PAL_TimerInit();
163  PAL_SpiInit();
164  PAL_GpioInit();
165 
166  /* Setup GPIOs */
167  PAL_GpioPinModeSet(LCD_PORT_SCLK, LCD_PIN_SCLK, palGpioModePushPull,0);
168  PAL_GpioPinModeSet(LCD_PORT_SI, LCD_PIN_SI, palGpioModePushPull,0);
169  PAL_GpioPinModeSet(LCD_PORT_SCS, LCD_PIN_SCS, palGpioModePushPull,0);
170 #if defined( LCD_PORT_DISP_SEL )
171  PAL_GpioPinModeSet(LCD_PORT_DISP_SEL,LCD_PIN_DISP_SEL,palGpioModePushPull,0);
172 #endif
173 
174 #if defined( LCD_PORT_DISP_PWR )
175  PAL_GpioPinModeSet(LCD_PORT_DISP_PWR,LCD_PIN_DISP_PWR,palGpioModePushPull,0);
176 #endif
177 
178 #if defined( LCD_PORT_EXTMODE )
179  PAL_GpioPinModeSet(LCD_PORT_EXTMODE, LCD_PIN_EXTMODE, palGpioModePushPull,0);
180 #endif
181  PAL_GpioPinModeSet(LCD_PORT_EXTCOMIN,LCD_PIN_EXTCOMIN,palGpioModePushPull,0);
182 
183 #ifdef PAL_TIMER_REPEAT_FUNCTION
184  /* If the platform specifies to use a timer repeat function we should
185  register the DisplayPolarityInverse to be called every second in
186  order to toggle the EXTCOMIN pin at 1Hz.
187  */
188  status =
189  PAL_TimerRepeat((void(*)(void*)) DisplayPolarityInverse, 0,
190  LS013B7DH03_POLARITY_INVERSION_FREQUENCY);
191 #elif defined POLARITY_INVERSION_EXTCOMIN_PAL_AUTO_TOGGLE
192  /* Setup system (via PAL) to toggle the EXTCOMIN pin every second. */
193  status = PAL_GpioPinAutoToggle(LCD_PORT_EXTCOMIN, LCD_PIN_EXTCOMIN,
194  LS013B7DH03_POLARITY_INVERSION_FREQUENCY);
195 #else
196  /* System does not support toggling the EXTCOMIN pin. Return error. */
198 #endif
199  if (PAL_EMSTATUS_OK != status)
200  {
201  return status;
202  }
203 
204  /* Setup and register the LS013B7DH03 as a DISPLAY device now. */
205  display.name = SHARP_MEMLCD_DEVICE_NAME;
208  display.geometry.width = LS013B7DH03_WIDTH;
209  display.geometry.height = LS013B7DH03_HEIGHT;
210  /* stride = pixels + ctrl bytes */
211  display.geometry.stride =
212  display.geometry.width + LS013B7DH03_CONTROL_BYTES*8;
213 
214  display.pDisplayPowerOn = DisplayEnable;
215 #ifdef PIXEL_MATRIX_ALLOC_SUPPORT
216  display.pPixelMatrixAllocate = PixelMatrixAllocate;
217  display.pPixelMatrixFree = PixelMatrixFree;
218 #else
219  display.pPixelMatrixAllocate = NULL;
220  display.pPixelMatrixFree = NULL;
221 #endif
222  display.pPixelMatrixDraw = PixelMatrixDraw;
223  display.pPixelMatrixClear = PixelMatrixClear;
224  display.pDriverRefresh = DriverRefresh;
225 
226  status = DISPLAY_DeviceRegister (&display);
227 
228  if (DISPLAY_EMSTATUS_OK == status)
229  {
230  /* Turn on display. */
231  DisplayEnable(&display, true);
232 
233  /* Clear display */
234  DisplayClear();
235  }
236 
237  return status;
238 }
239 
240 
241 /*******************************************************************************
242  ***************************** STATIC FUNCTIONS ****************************
243  ******************************************************************************/
244 
245 /**************************************************************************/
252 static EMSTATUS DriverRefresh(DISPLAY_Device_t* device)
253 {
254  EMSTATUS status = DISPLAY_EMSTATUS_OK;
255 
256  (void) device; /* Suppress compiler warning: unused parameter. */
257 
258  /* Reinitialize the timer and SPI configuration. */
259  PAL_TimerInit();
260  PAL_SpiInit();
261 
262  return status;
263 }
264 
265 
266 /**************************************************************************/
279 static EMSTATUS DisplayEnable(DISPLAY_Device_t* device,
280  bool enable)
281 {
282  (void) device; /* Suppress compiler warning: unused parameter. */
283 
284  if (enable)
285  {
286 #if defined( LCD_PORT_DISP_SEL )
287  /* Set EFM_DISP_SELECT pin. */
288  PAL_GpioPinOutSet(LCD_PORT_DISP_SEL, LCD_PIN_DISP_SEL);
289 #endif
290 
291 #if defined( LCD_PORT_DISP_PWR )
292  /* Drive voltage on EFM_DISP_PWR_EN pin. */
293  PAL_GpioPinOutSet(LCD_PORT_DISP_PWR, LCD_PIN_DISP_PWR);
294 #endif
295  }
296  else
297  {
298 #if defined( LCD_PORT_DISP_PWR )
299  /* Stop driving voltage on EFM_DISP_PWR_EN pin. */
300  PAL_GpioPinOutClear(LCD_PORT_DISP_PWR, LCD_PIN_DISP_PWR);
301 #endif
302 
303 #if defined( LCD_PORT_DISP_SEL )
304  /* Clear EFM_DISP_SELECT pin. */
305  PAL_GpioPinOutClear(LCD_PORT_DISP_SEL, LCD_PIN_DISP_SEL);
306 #endif
307  }
308 
309  return DISPLAY_EMSTATUS_OK;
310 }
311 
312 
313 /**************************************************************************/
320 static EMSTATUS DisplayClear ( void )
321 {
322  uint16_t cmd;
323 
324  /* Set SCS */
325  PAL_GpioPinOutSet( LCD_PORT_SCS, LCD_PIN_SCS );
326 
327  /* SCS setup time: min 6us */
328  PAL_TimerMicroSecondsDelay(6);
329 
330  /* Send command */
331  cmd = LS013B7DH03_CMD_ALL_CLEAR | lcdPolarity;
332  PAL_SpiTransmit ((uint8_t*) &cmd, 2 );
333 
334  /* SCS hold time: min 2us */
335  PAL_TimerMicroSecondsDelay(2);
336 
337  /* Clear SCS */
338  PAL_GpioPinOutClear( LCD_PORT_SCS, LCD_PIN_SCS );
339 
340  return DISPLAY_EMSTATUS_OK;
341 }
342 
343 
344 #ifdef PAL_TIMER_REPEAT_FUNCTION
345 
346 /**************************************************************************/
354 static EMSTATUS DisplayPolarityInverse (void)
355 {
356 #ifdef POLARITY_INVERSION_EXTCOMIN
357 
358  /* Toggle extcomin gpio */
359  PAL_GpioPinOutToggle( LCD_PORT_EXTCOMIN, LCD_PIN_EXTCOMIN );
360 
361 #else /* POLARITY_INVERSION_EXTCOMIN */
362 
363  /* Send a packet with inverted com */
364  PAL_GpioPinOutSet( LCD_PORT_SCS, LCD_PIN_SCS );
365 
366  /* SCS setup time: min 6us */
367  PAL_TimerMicroSecondsDelay(6);
368 
369  /* Send polarity command including dummy bits */
370  PAL_SpiTransmit ((uint8_t*) &lcdPolarity, 2 );
371 
372  /* SCS hold time: min 2us */
373  PAL_TimerMicroSecondsDelay(2);
374 
375  PAL_GpioPinOutClear( LCD_PORT_SCS, LCD_PIN_SCS );
376 
377  /* Invert com polarity */
378  if (lcdPolarity == 0x00)
379  {
380  lcdPolarity = 0x02;
381  }
382  else
383  {
384  lcdPolarity = 0x00;
385  }
386 
387 #endif /* POLARITY_INVERSION_EXTCOMIN */
388 
389  return DISPLAY_EMSTATUS_OK;
390 }
391 
392 #endif /* POLARITY_INVERSION_EXTCOMIN_PAL_AUTO_TOGGLE */
393 
394 
395 #ifdef PIXEL_MATRIX_ALLOC_SUPPORT
396 /**************************************************************************/
414 static EMSTATUS PixelMatrixAllocate( DISPLAY_Device_t* device,
415  unsigned int width,
416 #ifdef EMWIN_WORKAROUND
417  unsigned int userStride,
418 #endif
419  unsigned int height,
420  DISPLAY_PixelMatrix_t *pixelMatrix)
421 {
422 #ifdef EMWIN_WORKAROUND
423  unsigned int allocSize = (userStride/8 + LS013B7DH03_CONTROL_BYTES) * height;
424 #else
425  unsigned int allocSize = (width/8 + LS013B7DH03_CONTROL_BYTES) * height;
426 #endif
427 
428  (void) device; /* Suppress compiler warning: unused parameter. */
429 
430  if (width != LS013B7DH03_WIDTH)
432 #ifdef EMWIN_WORKAROUND
433  if (userStride < width)
435 #endif
436 
437 #ifdef USE_MALLOC
438 
439  /* Allocate the pixel matrix buffer including 2 control bytes per line. */
440  *pixelMatrix = (DISPLAY_PixelMatrix_t) malloc (allocSize);
441 
442  if (NULL == *pixelMatrix)
444  else
445  return DISPLAY_EMSTATUS_OK;
446 
447 #endif /* USE_MALLOC */
448 
449 #ifdef USE_STATIC_PIXEL_MATRIX_POOL
450 
451  if (((uint8_t*)pixelMatrixPool) + allocSize >
452  ((uint8_t*)pixelMatrixPoolBase) + PIXEL_MATRIX_POOL_SIZE)
453  {
454  *pixelMatrix = NULL;
456  }
457  else
458  {
459  *pixelMatrix = pixelMatrixPool;
460  pixelMatrixPool += allocSize / sizeof(PixelMatrixAlign_t) +
461  ((allocSize % sizeof(PixelMatrixAlign_t))? 1 : 0);
462  return DISPLAY_EMSTATUS_OK;
463  }
464 
465 #endif /* USE_STATIC_PIXEL_MATRIX_POOL */
466 
467 }
468 #endif /* PIXEL_MATRIX_ALLOC_SUPPORT */
469 
470 
471 #ifdef PIXEL_MATRIX_ALLOC_SUPPORT
472 /**************************************************************************/
482 static EMSTATUS PixelMatrixFree( DISPLAY_Device_t* device,
483  DISPLAY_PixelMatrix_t pixelMatrix)
484 {
485  (void) device; /* Suppress compiler warning: unused parameter. */
486 
487 #ifdef USE_MALLOC
488  free(pixelMatrix);
489  return DISPLAY_EMSTATUS_OK;
490 #endif /* USE_MALLOC */
491 
492 #ifdef USE_STATIC_PIXEL_MATRIX_POOL
493  /* The non-malloc PixelMatrixAllocate function only allocates buffers
494  consequtively from a pool. It is not possible to free the buffers.
495  I.e. this allocator can only be used for one-shot allocations of
496  buffers that will should never be freed and re-alloced.
497  */
498  (void) pixelMatrix; /* Supress compiles warning: unused parameter. */
500 #endif
501 }
502 #endif /* PIXEL_MATRIX_ALLOC_SUPPORT */
503 
504 
505 /**************************************************************************/
522 static EMSTATUS PixelMatrixClear( DISPLAY_Device_t* device,
523  DISPLAY_PixelMatrix_t pixelMatrix,
524  unsigned int width,
525  unsigned int height)
526 {
527  uint8_t* pByte = (uint8_t*) pixelMatrix;
528  unsigned int i;
529 
530  (void) device; /* Suppress compiler warning: unused parameter. */
531  (void) width; /* Suppress compiler warning: unused parameter. */
532 
533  for (i=0; i<height; i++)
534  {
535  /* Clear line */
536  memset(pByte, 0, LS013B7DH03_WIDTH/8);
537  pByte += LS013B7DH03_WIDTH/8;
538 
539 #ifdef USE_CONTROL_BYTES
540  /* Set dummy byte. */
541  *pByte++ = 0xff;
542  /* Set address of next line */
543  *pByte++ = i+1;
544 #endif
545  }
546 
547  return DISPLAY_EMSTATUS_OK;
548 }
549 
550 
551 #ifdef USE_CONTROL_BYTES
552 /**************************************************************************/
563 static EMSTATUS pixelMatrixSetup( DISPLAY_PixelMatrix_t pixelMatrix,
564  unsigned int startRow,
565  unsigned int height
566 #ifdef EMWIN_WORKAROUND
567  ,
568  unsigned int userStride
569 #endif
570  )
571 {
572  int i = 0;
573  uint8_t* pByte = (uint8_t*) pixelMatrix;
574 #ifdef EMWIN_WORKAROUND
575  int strideGap =
576  (userStride-LS013B7DH03_WIDTH-(LS013B7DH03_CONTROL_BYTES*8)) /
577  8 / sizeof(uint8_t);
578  if ((userStride-LS013B7DH03_WIDTH) % sizeof(uint16_t))
580 #endif
581 
582  while (i<height)
583  {
584  pByte += LS013B7DH03_WIDTH/8;
585  /* Set dummy byte. */
586  *pByte++ = 0xff;
587 
588  if (i == height-1)
589  {
590  /* Set dummy data at end of last line. */
591  *pByte++ = 0xff;
592  break;
593  }
594  else
595  /* Set address of next line */
596  *pByte++ = startRow + (++i);
597 
598 #ifdef EMWIN_WORKAROUND
599  pByte += strideGap;
600 #endif
601  }
602 
603  return DISPLAY_EMSTATUS_OK;
604 }
605 
606 #endif /* USE_CONTROL_BYTES */
607 
608 
609 /**************************************************************************/
626 static EMSTATUS PixelMatrixDraw( DISPLAY_Device_t* device,
627  DISPLAY_PixelMatrix_t pixelMatrix,
628  unsigned int startColumn,
629  unsigned int width,
630 #ifdef EMWIN_WORKAROUND
631  unsigned int userStride,
632 #endif
633  unsigned int startRow,
634  unsigned int height )
635 {
636  unsigned int i;
637  uint16_t* p = (uint16_t *)pixelMatrix;
638  uint16_t cmd;
639 #ifdef EMWIN_WORKAROUND
640  int strideGap =
641  (userStride-width-(LS013B7DH03_CONTROL_BYTES*8)) / 8 / sizeof(uint16_t);
642  if ((userStride-width) % sizeof(uint16_t))
644 #else
645  (void) width; /* Suppress compiler warning: unused parameter. */
646 #endif
647  (void) startColumn; /* Suppress compiler warning: unused parameter. */
648  (void) device; /* Suppress compiler warning: unused parameter. */
649 
650  /* Need to adjust start row by one because LS013B7DH03 starts counting lines
651  from 1, while the DISPLAY interface starts from 0. */
652  startRow++;
653 
654 #ifdef USE_CONTROL_BYTES
655  /* Setup line addressing in control words. */
656  pixelMatrixSetup(pixelMatrix, startRow, height
657 #ifdef EMWIN_WORKAROUND
658  , userStride
659 #endif
660  );
661 #endif
662 
663  /* Assert SCS */
664  PAL_GpioPinOutSet( LCD_PORT_SCS, LCD_PIN_SCS );
665 
666  /* SCS setup time: min 6us */
667  PAL_TimerMicroSecondsDelay(6);
668 
669  /* Send update command and first line address */
670  cmd = LS013B7DH03_CMD_UPDATE | (startRow << 8);
671  PAL_SpiTransmit((uint8_t*) &cmd, 2 );
672 
673  /* Get start address to draw from */
674  for ( i=0; i<height; i++ ) {
675 
676  /* Send pixels for this line */
677  PAL_SpiTransmit((uint8_t*) p,
678  LS013B7DH03_WIDTH/8 + LS013B7DH03_CONTROL_BYTES);
679  p+=(LS013B7DH03_WIDTH/8 + LS013B7DH03_CONTROL_BYTES) / sizeof(uint16_t);
680 
681 #ifndef USE_CONTROL_BYTES
682  if (i==height-1)
683  {
684  cmd = 0xffff;
685  }
686  else
687  {
688  cmd = 0xff | ((startRow+i+1) << 8);
689  }
690  PAL_SpiTransmit((uint8_t*) &cmd, 2 );
691 #endif
692 
693 #ifdef EMWIN_WORKAROUND
694  p += strideGap;
695 #endif
696 
697  }
698 
699  /* SCS hold time: min 2us */
700  PAL_TimerMicroSecondsDelay(2);
701 
702  /* De-assert SCS */
703  PAL_GpioPinOutClear( LCD_PORT_SCS, LCD_PIN_SCS );
704 
705  return DISPLAY_EMSTATUS_OK;
706 }
707 
DISPLAY_ColourMode_t colourMode
Definition: display.h:112
EMSTATUS(* pPixelMatrixClear)(struct DISPLAY_Device_t *device, DISPLAY_PixelMatrix_t pixelMatrix, unsigned int width, unsigned int height)
Definition: display.h:147
#define DISPLAY_EMSTATUS_INVALID_PARAMETER
Definition: display.h:50
#define DISPLAY_EMSTATUS_NOT_ENOUGH_MEMORY
Definition: display.h:48
EMSTATUS DISPLAY_DeviceRegister(DISPLAY_Device_t *device)
Register a display device.
Definition: display.c:172
Display device backend interface.
EMSTATUS(* pDriverRefresh)(struct DISPLAY_Device_t *device)
Definition: display.h:155
EMSTATUS(* pPixelMatrixDraw)(struct DISPLAY_Device_t *device, DISPLAY_PixelMatrix_t pixelMatrix, unsigned int startColumn, unsigned int width, unsigned int startRow, unsigned int height)
Definition: display.h:136
EMSTATUS(* pDisplayPowerOn)(struct DISPLAY_Device_t *device, bool on)
Definition: display.h:116
EMSTATUS(* pPixelMatrixFree)(struct DISPLAY_Device_t *device, DISPLAY_PixelMatrix_t pixelMatrix)
Definition: display.h:131
Platform Abstraction Layer (PAL) interface for DISPLAY driver.
General Purpose IO (GPIO) peripheral API.
unsigned int width
Definition: display.h:93
unsigned int stride
Definition: display.h:94
unsigned int height
Definition: display.h:96
#define PAL_EMSTATUS_OK
Definition: displaypal.h:34
#define DISPLAY_EMSTATUS_OK
Definition: display.h:47
Main configuration file for the DISPLAY driver software stack.
#define DISPLAY_EMSTATUS_OUT_OF_RANGE
Definition: display.h:49
DISPLAY_Geometry_t geometry
Definition: display.h:111
Configuration for the display driver for the Sharp Memory LCD LS013B7DH03.
#define DISPLAY_EMSTATUS_NOT_SUPPORTED
Definition: display.h:51
EMSTATUS(* pPixelMatrixAllocate)(struct DISPLAY_Device_t *device, unsigned int width, unsigned int height, DISPLAY_PixelMatrix_t *pixelMatrix)
Definition: display.h:121
void * DISPLAY_PixelMatrix_t
Definition: display.h:83
DISPLAY_AddressMode_t addressMode
Definition: display.h:113