drivers/lcd/tft/hw/ILI9325.c

   1 /**************************************************************************/
   2 /*!
   3     @file     ILI9325.c
   4     @author   K. Townsend (microBuilder.eu)
   5
   6     @section  DESCRIPTION
   7
   8     Driver for ILI9325 240x320 pixel TFT LCD displays.
   9
  10     This driver uses an 8-bit interface and a 16-bit RGB565 colour palette.
  11     Should also work with SPFD5408B or OTM3225A-based LCDs, though
  12     there are sometimes minor differences (for example vertical scrolling
  13     via register 0x6A isn't supported on all controllers).
  14
  15     @section  UPDATES
  16
  17     26-11-2010: ili9325ReadData contributed by Adafruit Industries
  18
  19     @section  LICENSE
  20
  21     Software License Agreement (BSD License)
  22
  23     Copyright (c) 2010, microBuilder SARL
  24     All rights reserved.
  25
  26     Redistribution and use in source and binary forms, with or without
  27     modification, are permitted provided that the following conditions are met:
  28     1. Redistributions of source code must retain the above copyright
  29     notice, this list of conditions and the following disclaimer.
  30     2. Redistributions in binary form must reproduce the above copyright
  31     notice, this list of conditions and the following disclaimer in the
  32     documentation and/or other materials provided with the distribution.
  33     3. Neither the name of the copyright holders nor the
  34     names of its contributors may be used to endorse or promote products
  35     derived from this software without specific prior written permission.
  36
  37     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
  38     EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  39     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  40     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
  41     DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  42     (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  43     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  44     ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  45     (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  46     SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  47 */
  48 /**************************************************************************/
  49 #include "ILI9325.h"
  50 #include "core/systick/systick.h"
  51 #include "drivers/lcd/tft/touchscreen.h"
  52
  53 static lcdOrientation_t lcdOrientation = LCD_ORIENTATION_PORTRAIT;
  54 static lcdProperties_t ili9325Properties = { 240, 320, TRUE, TRUE, TRUE };
  55
  56 /*************************************************/
  57 /* Private Methods                               */
  58 /*************************************************/
  59
  60 /**************************************************************************/
  61 /*!
  62     @brief  Causes a brief delay (10 ticks per unit)
  63 */
  64 /**************************************************************************/
  65 void ili9325Delay(unsigned int t)
  66 {
  67   unsigned char t1;
  68   while(t--)
  69   for ( t1=10; t1 > 0; t1-- )
  70   {
  71     __asm("nop");
  72   }
  73 }
  74
  75 /**************************************************************************/
  76 /*!
  77     @brief  Writes the supplied 16-bit command using an 8-bit interface
  78 */
  79 /**************************************************************************/
  80 void ili9325WriteCmd(uint16_t command)
  81 {
  82   // Compiled with -Os on GCC 4.4 this works out to 25 cycles
  83   // (versus 36 compiled with no optimisations).  I'm not sure it
  84   // can be improved further, so that means 25 cycles/350nS for
  85   // continuous writes (cmd, data, data, data, ...) or ~150 cycles/
  86   // ~2.1uS for a random pixel (Set X [cmd+data], Set Y [cmd+data],
  87   // Set color [cmd+data]) (times assumes 72MHz clock).
  88
  89   CLR_CS_CD_SET_RD_WR;  // Saves 18 commands compared to "CLR_CS; CLR_CD; SET_RD; SET_WR;"
  90   ILI9325_GPIO2DATA_DATA = (command >> (8 - ILI9325_DATA_OFFSET));
  91   CLR_WR;
  92   SET_WR;
  93   ILI9325_GPIO2DATA_DATA = command << ILI9325_DATA_OFFSET;
  94   CLR_WR;
  95   SET_WR_CS;            // Saves 7 commands compared to "SET_WR; SET_CS;"
  96 }
  97
  98 /**************************************************************************/
  99 /*!
 100     @brief  Writes the supplied 16-bit data using an 8-bit interface
 101 */
 102 /**************************************************************************/
 103 void ili9325WriteData(uint16_t data)
 104 {
 105   CLR_CS_SET_CD_RD_WR;  // Saves 18 commands compared to SET_CD; SET_RD; SET_WR; CLR_CS"
 106   ILI9325_GPIO2DATA_DATA = (data >> (8 - ILI9325_DATA_OFFSET));
 107   CLR_WR;
 108   SET_WR;
 109   ILI9325_GPIO2DATA_DATA = data << ILI9325_DATA_OFFSET;
 110   CLR_WR;
 111   SET_WR_CS;            // Saves 7 commands compared to "SET_WR, SET_CS;"
 112 }
 113
 114 /**************************************************************************/
 115 /*!
 116     @brief  Reads a 16-bit value from the 8-bit data bus
 117 */
 118 /**************************************************************************/
 119 uint16_t ili9325ReadData(void)
 120 {
 121   // ToDo: Optimise this method!
 122
 123   uint16_t high, low;
 124   high = low = 0;
 125   uint16_t d;
 126
 127   SET_CD_RD_WR;   // Saves 14 commands compared to "SET_CD; SET_RD; SET_WR"
 128   CLR_CS;
 129
 130   // set inputs
 131   ILI9325_GPIO2DATA_SETINPUT;
 132   CLR_RD;
 133   ili9325Delay(100);
 134   high = ILI9325_GPIO2DATA_DATA;
 135   high >>= ILI9325_DATA_OFFSET;
 136   high &= 0xFF;
 137   SET_RD;
 138
 139   CLR_RD;
 140   ili9325Delay(100);
 141   low = ILI9325_GPIO2DATA_DATA;
 142   low >>= ILI9325_DATA_OFFSET;
 143   low &=0xFF;
 144   SET_RD;
 145
 146   SET_CS;
 147   ILI9325_GPIO2DATA_SETOUTPUT;
 148
 149   d = high;
 150   d <<= 8;
 151   d |= low;
 152
 153   return d;
 154 }
 155
 156 /**************************************************************************/
 157 /*!
 158     @brief  Reads a 16-bit value
 159 */
 160 /**************************************************************************/
 161 uint16_t ili9325Read(uint16_t addr)
 162 {
 163   ili9325WriteCmd(addr);
 164   return ili9325ReadData();
 165 }
 166
 167 /**************************************************************************/
 168 /*!
 169     @brief  Sends a 16-bit command + 16-bit data
 170 */
 171 /**************************************************************************/
 172 void ili9325Command(uint16_t command, uint16_t data)
 173 {
 174   ili9325WriteCmd(command);
 175   ili9325WriteData(data);
 176 }
 177
 178 /**************************************************************************/
 179 /*!
 180     @brief  Returns the 16-bit (4-hexdigit) controller code
 181 */
 182 /**************************************************************************/
 183 uint16_t ili9325Type(void)
 184 {
 185   ili9325WriteCmd(ILI9325_COMMANDS_DRIVERCODEREAD);
 186   return ili9325ReadData();
 187 }
 188
 189 /**************************************************************************/
 190 /*!
 191     @brief  Sets the cursor to the specified X/Y position
 192 */
 193 /**************************************************************************/
 194 void ili9325SetCursor(uint16_t x, uint16_t y)
 195 {
 196   uint16_t al, ah;
 197
 198   if (lcdOrientation == LCD_ORIENTATION_LANDSCAPE)
 199   {
 200     al = y;
 201     ah = x;
 202   }
 203   else
 204   {
 205     al = x;
 206     ah = y;
 207   }
 208
 209   ili9325Command(ILI9325_COMMANDS_HORIZONTALGRAMADDRESSSET, al);
 210   ili9325Command(ILI9325_COMMANDS_VERTICALGRAMADDRESSSET, ah);
 211 }
 212
 213 /**************************************************************************/
 214 /*!
 215     @brief  Sends the initialisation sequence to the display controller
 216 */
 217 /**************************************************************************/
 218 void ili9325InitDisplay(void)
 219 {
 220   // Clear data line
 221   GPIO_GPIO2DATA &= ~ILI9325_DATA_MASK;
 222
 223   SET_RD;
 224   SET_WR;
 225   SET_CS;
 226   SET_CD;
 227
 228   // Reset display
 229   CLR_RESET;
 230   ili9325Delay(10000);
 231   SET_RESET;
 232   ili9325Delay(500);
 233
 234   ili9325Command(ILI9325_COMMANDS_DRIVEROUTPUTCONTROL1, 0x0100);  // Driver Output Control Register (R01h)
 235   ili9325Command(ILI9325_COMMANDS_LCDDRIVINGCONTROL, 0x0700);     // LCD Driving Waveform Control (R02h)
 236   ili9325Command(ILI9325_COMMANDS_ENTRYMODE, 0x1030);             // Entry Mode (R03h)
 237   ili9325Command(ILI9325_COMMANDS_DISPLAYCONTROL2, 0x0302);
 238   ili9325Command(ILI9325_COMMANDS_DISPLAYCONTROL3, 0x0000);
 239   ili9325Command(ILI9325_COMMANDS_DISPLAYCONTROL4, 0x0000);       // Fmark On
 240   ili9325Command(ILI9325_COMMANDS_POWERCONTROL1, 0x0000);         // Power Control 1 (R10h)
 241   ili9325Command(ILI9325_COMMANDS_POWERCONTROL2, 0x0007);         // Power Control 2 (R11h)
 242   ili9325Command(ILI9325_COMMANDS_POWERCONTROL3, 0x0000);         // Power Control 3 (R12h)
 243   ili9325Command(ILI9325_COMMANDS_POWERCONTROL4, 0x0000);         // Power Control 4 (R13h)
 244   ili9325Delay(1000);
 245   ili9325Command(ILI9325_COMMANDS_POWERCONTROL1, 0x14B0);         // Power Control 1 (R10h)
 246   ili9325Delay(500);
 247   ili9325Command(ILI9325_COMMANDS_POWERCONTROL2, 0x0007);         // Power Control 2 (R11h)
 248   ili9325Delay(500);
 249   ili9325Command(ILI9325_COMMANDS_POWERCONTROL3, 0x008E);         // Power Control 3 (R12h)
 250   ili9325Command(ILI9325_COMMANDS_POWERCONTROL4, 0x0C00);         // Power Control 4 (R13h)
 251   ili9325Command(ILI9325_COMMANDS_POWERCONTROL7, 0x0015);         // NVM read data 2 (R29h)
 252   ili9325Delay(500);
 253   ili9325Command(ILI9325_COMMANDS_GAMMACONTROL1, 0x0000);         // Gamma Control 1
 254   ili9325Command(ILI9325_COMMANDS_GAMMACONTROL2, 0x0107);         // Gamma Control 2
 255   ili9325Command(ILI9325_COMMANDS_GAMMACONTROL3, 0x0000);         // Gamma Control 3
 256   ili9325Command(ILI9325_COMMANDS_GAMMACONTROL4, 0x0203);         // Gamma Control 4
 257   ili9325Command(ILI9325_COMMANDS_GAMMACONTROL5, 0x0402);         // Gamma Control 5
 258   ili9325Command(ILI9325_COMMANDS_GAMMACONTROL6, 0x0000);         // Gamma Control 6
 259   ili9325Command(ILI9325_COMMANDS_GAMMACONTROL7, 0x0207);         // Gamma Control 7
 260   ili9325Command(ILI9325_COMMANDS_GAMMACONTROL8, 0x0000);         // Gamma Control 8
 261   ili9325Command(ILI9325_COMMANDS_GAMMACONTROL9, 0x0203);         // Gamma Control 9
 262   ili9325Command(ILI9325_COMMANDS_GAMMACONTROL10, 0x0403);        // Gamma Control 10
 263   ili9325Command(ILI9325_COMMANDS_HORIZONTALADDRESSSTARTPOSITION, 0x0000);                      // Window Horizontal RAM Address Start (R50h)
 264   ili9325Command(ILI9325_COMMANDS_HORIZONTALADDRESSENDPOSITION, ili9325Properties.width - 1);   // Window Horizontal RAM Address End (R51h)
 265   ili9325Command(ILI9325_COMMANDS_VERTICALADDRESSSTARTPOSITION, 0X0000);                        // Window Vertical RAM Address Start (R52h)
 266   ili9325Command(ILI9325_COMMANDS_VERTICALADDRESSENDPOSITION, ili9325Properties.height - 1);    // Window Vertical RAM Address End (R53h)
 267   ili9325Command(ILI9325_COMMANDS_DRIVEROUTPUTCONTROL2, 0xa700);    // Driver Output Control (R60h)
 268   ili9325Command(ILI9325_COMMANDS_BASEIMAGEDISPLAYCONTROL, 0x0003); // Driver Output Control (R61h) - enable VLE
 269   ili9325Command(ILI9325_COMMANDS_PANELINTERFACECONTROL1, 0X0010);  // Panel Interface Control 1 (R90h)
 270
 271   // Display On
 272   ili9325Command(ILI9325_COMMANDS_DISPLAYCONTROL1, 0x0133);     // Display Control (R07h)
 273   ili9325Delay(500);
 274   ili9325WriteCmd(ILI9325_COMMANDS_WRITEDATATOGRAM);
 275 }
 276
 277 /**************************************************************************/
 278 /*!
 279     @brief  Sets the cursor to the home position (0,0)
 280 */
 281 /**************************************************************************/
 282 void ili9325Home(void)
 283 {
 284   ili9325SetCursor(0, 0);
 285   ili9325WriteCmd(ILI9325_COMMANDS_WRITEDATATOGRAM);            // Write Data to GRAM (R22h)
 286 }
 287
 288 /**************************************************************************/
 289 /*!
 290     @brief  Sets the window confines
 291 */
 292 /**************************************************************************/
 293 void ili9325SetWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1)
 294 {
 295   ili9325Command(ILI9325_COMMANDS_HORIZONTALADDRESSSTARTPOSITION, x0);
 296   ili9325Command(ILI9325_COMMANDS_HORIZONTALADDRESSENDPOSITION, x1);
 297   ili9325Command(ILI9325_COMMANDS_VERTICALADDRESSSTARTPOSITION, y0);
 298   ili9325Command(ILI9325_COMMANDS_VERTICALADDRESSENDPOSITION, y1);
 299   ili9325SetCursor(x0, y0);
 300 }
 301
 302 /*************************************************/
 303 /* Public Methods                                */
 304 /*************************************************/
 305
 306 /**************************************************************************/
 307 /*!
 308     @brief  Configures any pins or HW and initialises the LCD controller
 309 */
 310 /**************************************************************************/
 311 void lcdInit(void)
 312 {
 313   // Set control line pins to output
 314   gpioSetDir(ILI9325_CS_PORT, ILI9325_CS_PIN, 1);
 315   gpioSetDir(ILI9325_CD_PORT, ILI9325_CD_PIN, 1);
 316   gpioSetDir(ILI9325_WR_PORT, ILI9325_WR_PIN, 1);
 317   gpioSetDir(ILI9325_RD_PORT, ILI9325_RD_PIN, 1);
 318
 319   // Set data port pins to output
 320   ILI9325_GPIO2DATA_SETOUTPUT;
 321
 322   // Disable pullups
 323   ILI9325_DISABLEPULLUPS();
 324
 325   // Set backlight pin to output and turn it on
 326   gpioSetDir(ILI9325_BL_PORT, ILI9325_BL_PIN, 1);      // set to output
 327   lcdBacklight(TRUE);
 328
 329   // Set reset pin to output
 330   gpioSetDir(ILI9325_RES_PORT, ILI9325_RES_PIN, 1);    // Set to output
 331   gpioSetValue(ILI9325_RES_PORT, ILI9325_RES_PIN, 0);  // Low to reset
 332   systickDelay(50);
 333   gpioSetValue(ILI9325_RES_PORT, ILI9325_RES_PIN, 1);  // High to exit
 334
 335   // Initialize the display
 336   ili9325InitDisplay();
 337
 338   systickDelay(50);
 339
 340   // Set lcd to default orientation
 341   lcdSetOrientation(lcdOrientation);
 342
 343   // Fill black
 344   lcdFillRGB(COLOR_BLACK);
 345
 346   // Initialise the touch screen (and calibrate if necessary)
 347   tsInit();
 348 }
 349
 350 /**************************************************************************/
 351 /*!
 352     @brief  Enables or disables the LCD backlight
 353 */
 354 /**************************************************************************/
 355 void lcdBacklight(bool state)
 356 {
 357   // Set the backlight
 358   gpioSetValue(ILI9325_BL_PORT, ILI9325_BL_PIN, state ? 0 : 1);
 359 }
 360
 361 /**************************************************************************/
 362 /*!
 363     @brief  Renders a simple test pattern on the LCD
 364 */
 365 /**************************************************************************/
 366 void lcdTest(void)
 367 {
 368   uint32_t i,j;
 369   ili9325Home();
 370
 371   for(i=0;i<320;i++)
 372   {
 373     for(j=0;j<240;j++)
 374     {
 375       if(i>279)ili9325WriteData(COLOR_WHITE);
 376       else if(i>239)ili9325WriteData(COLOR_BLUE);
 377       else if(i>199)ili9325WriteData(COLOR_GREEN);
 378       else if(i>159)ili9325WriteData(COLOR_CYAN);
 379       else if(i>119)ili9325WriteData(COLOR_RED);
 380       else if(i>79)ili9325WriteData(COLOR_MAGENTA);
 381       else if(i>39)ili9325WriteData(COLOR_YELLOW);
 382       else ili9325WriteData(COLOR_BLACK);
 383     }
 384   }
 385 }
 386
 387 /**************************************************************************/
 388 /*!
 389     @brief  Fills the LCD with the specified 16-bit color
 390 */
 391 /**************************************************************************/
 392 void lcdFillRGB(uint16_t data)
 393 {
 394   unsigned int i;
 395   ili9325Home();
 396
 397   uint32_t pixels = 320*240;
 398   for ( i=0; i < pixels; i++ )
 399   {
 400     ili9325WriteData(data);
 401   }
 402 }
 403
 404 /**************************************************************************/
 405 /*!
 406     @brief  Draws a single pixel at the specified X/Y location
 407 */
 408 /**************************************************************************/
 409 void lcdDrawPixel(uint16_t x, uint16_t y, uint16_t color)
 410 {
 411   ili9325SetCursor(x, y);
 412   ili9325WriteCmd(ILI9325_COMMANDS_WRITEDATATOGRAM);  // Write Data to GRAM (R22h)
 413   ili9325WriteData(color);
 414 }
 415
 416 /**************************************************************************/
 417 /*!
 418     @brief  Draws an array of consecutive RGB565 pixels (much
 419             faster than addressing each pixel individually)
 420 */
 421 /**************************************************************************/
 422 void lcdDrawPixels(uint16_t x, uint16_t y, uint16_t *data, uint32_t len)
 423 {
 424   uint32_t i = 0;
 425   ili9325SetCursor(x, y);
 426   ili9325WriteCmd(ILI9325_COMMANDS_WRITEDATATOGRAM);
 427   do
 428   {
 429     ili9325WriteData(data[i]);
 430     i++;
 431   } while (i<len);
 432 }
 433
 434 /**************************************************************************/
 435 /*!
 436     @brief  Optimised routine to draw a horizontal line faster than
 437             setting individual pixels
 438 */
 439 /**************************************************************************/
 440 void lcdDrawHLine(uint16_t x0, uint16_t x1, uint16_t y, uint16_t color)
 441 {
 442   // Allows for slightly better performance than setting individual pixels
 443   uint16_t x, pixels;
 444
 445   if (x1 < x0)
 446   {
 447     // Switch x1 and x0
 448     x = x1;
 449     x1 = x0;
 450     x0 = x;
 451   }
 452
 453   // Check limits
 454   if (x1 >= lcdGetWidth())
 455   {
 456     x1 = lcdGetWidth() - 1;
 457   }
 458   if (x0 >= lcdGetWidth())
 459   {
 460     x0 = lcdGetWidth() - 1;
 461   }
 462
 463   ili9325SetCursor(x0, y);
 464   ili9325WriteCmd(ILI9325_COMMANDS_WRITEDATATOGRAM);  // Write Data to GRAM (R22h)
 465   for (pixels = 0; pixels < x1 - x0 + 1; pixels++)
 466   {
 467     ili9325WriteData(color);
 468   }
 469 }
 470
 471 /**************************************************************************/
 472 /*!
 473     @brief  Optimised routine to draw a vertical line faster than
 474             setting individual pixels
 475 */
 476 /**************************************************************************/
 477 void lcdDrawVLine(uint16_t x, uint16_t y0, uint16_t y1, uint16_t color)
 478 {
 479   // Allows for slightly better performance than setting individual pixels
 480   lcdOrientation_t orientation = lcdOrientation;
 481
 482   // Switch orientation
 483   lcdSetOrientation(orientation == LCD_ORIENTATION_PORTRAIT ? LCD_ORIENTATION_LANDSCAPE : LCD_ORIENTATION_PORTRAIT);
 484
 485   // Draw horizontal line like usual
 486   lcdDrawHLine(y0, y1, lcdGetHeight() - (x + 1), color);
 487
 488   // Switch orientation back
 489   lcdSetOrientation(orientation);
 490 }
 491
 492 /**************************************************************************/
 493 /*!
 494     @brief  Gets the 16-bit color of the pixel at the specified location
 495 */
 496 /**************************************************************************/
 497 uint16_t lcdGetPixel(uint16_t x, uint16_t y)
 498 {
 499   uint16_t preFetch = 0;
 500
 501   ili9325SetCursor(x, y);
 502   ili9325WriteCmd(ILI9325_COMMANDS_WRITEDATATOGRAM);
 503   preFetch = ili9325ReadData();
 504
 505   // Eeek ... why does this need to be done twice for a proper value?!?
 506   ili9325SetCursor(x, y);
 507   ili9325WriteCmd(ILI9325_COMMANDS_WRITEDATATOGRAM);
 508   return ili9325ReadData();
 509 }
 510
 511 /**************************************************************************/
 512 /*!
 513     @brief  Sets the LCD orientation to horizontal and vertical
 514 */
 515 /**************************************************************************/
 516 void lcdSetOrientation(lcdOrientation_t orientation)
 517 {
 518   uint16_t entryMode = 0x1030;
 519   uint16_t outputControl = 0x0100;
 520
 521   switch (orientation)
 522   {
 523     case LCD_ORIENTATION_PORTRAIT:
 524       entryMode = 0x1030;
 525       outputControl = 0x0100;
 526       break;
 527     case LCD_ORIENTATION_LANDSCAPE:
 528       entryMode = 0x1028;
 529       outputControl = 0x0000;
 530       break;
 531   }
 532
 533   ili9325Command(ILI9325_COMMANDS_ENTRYMODE, entryMode);
 534   ili9325Command(ILI9325_COMMANDS_DRIVEROUTPUTCONTROL1, outputControl);
 535   lcdOrientation = orientation;
 536
 537   ili9325SetCursor(0, 0);
 538 }
 539
 540 /**************************************************************************/
 541 /*!
 542     @brief  Gets the current screen orientation (horizontal or vertical)
 543 */
 544 /**************************************************************************/
 545 lcdOrientation_t lcdGetOrientation(void)
 546 {
 547   return lcdOrientation;
 548 }
 549
 550 /**************************************************************************/
 551 /*!
 552     @brief  Gets the width in pixels of the LCD screen (varies depending
 553             on the current screen orientation)
 554 */
 555 /**************************************************************************/
 556 uint16_t lcdGetWidth(void)
 557 {
 558   switch (lcdOrientation)
 559   {
 560     case LCD_ORIENTATION_PORTRAIT:
 561       return ili9325Properties.width;
 562       break;
 563     case LCD_ORIENTATION_LANDSCAPE:
 564     default:
 565       return ili9325Properties.height;
 566   }
 567 }
 568
 569 /**************************************************************************/
 570 /*!
 571     @brief  Gets the height in pixels of the LCD screen (varies depending
 572             on the current screen orientation)
 573 */
 574 /**************************************************************************/
 575 uint16_t lcdGetHeight(void)
 576 {
 577   switch (lcdOrientation)
 578   {
 579     case LCD_ORIENTATION_PORTRAIT:
 580       return ili9325Properties.height;
 581       break;
 582     case LCD_ORIENTATION_LANDSCAPE:
 583     default:
 584       return ili9325Properties.width;
 585   }
 586 }
 587
 588 /**************************************************************************/
 589 /*!
 590     @brief  Scrolls the contents of the LCD screen vertically the
 591             specified number of pixels using a HW optimised routine
 592 */
 593 /**************************************************************************/
 594 void lcdScroll(int16_t pixels, uint16_t fillColor)
 595 {
 596   int16_t y = pixels;
 597   while (y < 0)
 598     y += 320;
 599   while (y >= 320)
 600     y -= 320;
 601   ili9325WriteCmd(ILI9325_COMMANDS_VERTICALSCROLLCONTROL);
 602   ili9325WriteData(y);
 603 }
 604
 605 /**************************************************************************/
 606 /*!
 607     @brief  Gets the controller's 16-bit (4 hexdigit) ID
 608 */
 609 /**************************************************************************/
 610 uint16_t lcdGetControllerID(void)
 611 {
 612   return ili9325Type();
 613 }
 614
 615 /**************************************************************************/
 616 /*!
 617     @brief  Returns the LCDs 'lcdProperties_t' that describes the LCDs
 618             generic capabilities and dimensions
 619 */
 620 /**************************************************************************/
 621 lcdProperties_t lcdGetProperties(void)
 622 {
 623     return ili9325Properties;
 624 }