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   lcdOrientation_t oldOrientation = lcdOrientation;
 480
 481   if (oldOrientation == LCD_ORIENTATION_PORTRAIT)
 482   {
 483     lcdSetOrientation(LCD_ORIENTATION_LANDSCAPE);
 484     lcdDrawHLine(y0, y1, lcdGetHeight() - (x + 1), color);
 485   }
 486   else
 487   {
 488     lcdSetOrientation(LCD_ORIENTATION_PORTRAIT);
 489     lcdDrawHLine(lcdGetWidth() - (y0 + 1), lcdGetWidth() - (y1 + 1), x, color);
 490   }
 491
 492   // Switch orientation back
 493   lcdSetOrientation(oldOrientation);
 494 }
 495
 496 /**************************************************************************/
 497 /*!
 498     @brief  Gets the 16-bit color of the pixel at the specified location
 499 */
 500 /**************************************************************************/
 501 uint16_t lcdGetPixel(uint16_t x, uint16_t y)
 502 {
 503   uint16_t preFetch = 0;
 504
 505   ili9325SetCursor(x, y);
 506   ili9325WriteCmd(ILI9325_COMMANDS_WRITEDATATOGRAM);
 507   preFetch = ili9325ReadData();
 508
 509   // Eeek ... why does this need to be done twice for a proper value?!?
 510   ili9325SetCursor(x, y);
 511   ili9325WriteCmd(ILI9325_COMMANDS_WRITEDATATOGRAM);
 512   return ili9325ReadData();
 513 }
 514
 515 /**************************************************************************/
 516 /*!
 517     @brief  Sets the LCD orientation to horizontal and vertical
 518 */
 519 /**************************************************************************/
 520 void lcdSetOrientation(lcdOrientation_t orientation)
 521 {
 522   uint16_t entryMode = 0x1030;
 523   uint16_t outputControl = 0x0100;
 524
 525   switch (orientation)
 526   {
 527     case LCD_ORIENTATION_PORTRAIT:
 528       entryMode = 0x1030;
 529       outputControl = 0x0100;
 530       break;
 531     case LCD_ORIENTATION_LANDSCAPE:
 532       entryMode = 0x1028;
 533       outputControl = 0x0000;
 534       break;
 535   }
 536
 537   ili9325Command(ILI9325_COMMANDS_ENTRYMODE, entryMode);
 538   ili9325Command(ILI9325_COMMANDS_DRIVEROUTPUTCONTROL1, outputControl);
 539   lcdOrientation = orientation;
 540
 541   ili9325SetCursor(0, 0);
 542 }
 543
 544 /**************************************************************************/
 545 /*!
 546     @brief  Gets the current screen orientation (horizontal or vertical)
 547 */
 548 /**************************************************************************/
 549 lcdOrientation_t lcdGetOrientation(void)
 550 {
 551   return lcdOrientation;
 552 }
 553
 554 /**************************************************************************/
 555 /*!
 556     @brief  Gets the width in pixels of the LCD screen (varies depending
 557             on the current screen orientation)
 558 */
 559 /**************************************************************************/
 560 uint16_t lcdGetWidth(void)
 561 {
 562   switch (lcdOrientation)
 563   {
 564     case LCD_ORIENTATION_PORTRAIT:
 565       return ili9325Properties.width;
 566       break;
 567     case LCD_ORIENTATION_LANDSCAPE:
 568     default:
 569       return ili9325Properties.height;
 570   }
 571 }
 572
 573 /**************************************************************************/
 574 /*!
 575     @brief  Gets the height in pixels of the LCD screen (varies depending
 576             on the current screen orientation)
 577 */
 578 /**************************************************************************/
 579 uint16_t lcdGetHeight(void)
 580 {
 581   switch (lcdOrientation)
 582   {
 583     case LCD_ORIENTATION_PORTRAIT:
 584       return ili9325Properties.height;
 585       break;
 586     case LCD_ORIENTATION_LANDSCAPE:
 587     default:
 588       return ili9325Properties.width;
 589   }
 590 }
 591
 592 /**************************************************************************/
 593 /*!
 594     @brief  Scrolls the contents of the LCD screen vertically the
 595             specified number of pixels using a HW optimised routine
 596 */
 597 /**************************************************************************/
 598 void lcdScroll(int16_t pixels, uint16_t fillColor)
 599 {
 600   int16_t y = pixels;
 601   while (y < 0)
 602     y += 320;
 603   while (y >= 320)
 604     y -= 320;
 605   ili9325WriteCmd(ILI9325_COMMANDS_VERTICALSCROLLCONTROL);
 606   ili9325WriteData(y);
 607 }
 608
 609 /**************************************************************************/
 610 /*!
 611     @brief  Gets the controller's 16-bit (4 hexdigit) ID
 612 */
 613 /**************************************************************************/
 614 uint16_t lcdGetControllerID(void)
 615 {
 616   return ili9325Type();
 617 }
 618
 619 /**************************************************************************/
 620 /*!
 621     @brief  Returns the LCDs 'lcdProperties_t' that describes the LCDs
 622             generic capabilities and dimensions
 623 */
 624 /**************************************************************************/
 625 lcdProperties_t lcdGetProperties(void)
 626 {
 627     return ili9325Properties;
 628 }