SAMV71 Xplained Ultra Software Package 1.0

ili9488.c

Go to the documentation of this file.
00001 /* ----------------------------------------------------------------------------
00002  *         SAM Software Package License
00003  * ----------------------------------------------------------------------------
00004  * Copyright (c) 2014, Atmel Corporation
00005  *
00006  * All rights reserved.
00007  *
00008  * Redistribution and use in source and binary forms, with or without
00009  * modification, are permitted provided that the following conditions are met:
00010  *
00011  * - Redistributions of source code must retain the above copyright notice,
00012  * this list of conditions and the disclaimer below.
00013  *
00014  * Atmel's name may not be used to endorse or promote products derived from
00015  * this software without specific prior written permission.
00016  *
00017  * DISCLAIMER: THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR
00018  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
00019  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
00020  * DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT, INDIRECT,
00021  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
00022  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
00023  * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
00024  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
00025  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
00026  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00027  * ----------------------------------------------------------------------------
00028  */
00029 
00030 /**
00031  * \file
00032  *
00033  * Implementation of ILI9488 driver.
00034  *
00035  */
00036 
00037 /*----------------------------------------------------------------------------
00038  *        Headers
00039  *----------------------------------------------------------------------------*/
00040 #include "board.h"
00041 
00042 #include <string.h>
00043 #include <stdio.h>
00044 
00045 #ifdef BOARD_LCD_ILI9488
00046 
00047 /*----------------------------------------------------------------------------
00048  *        Local variables
00049  *----------------------------------------------------------------------------*/
00050 
00051 #define ILI9488     SPI0
00052 #define ILI9488_ID  ID_SPI0
00053 
00054 /** Pio pins to configure. */
00055 static const Pin ILI9488_Reset[] = LCD_PIN_RESET;
00056 
00057 static const Pin ILI9488_Pwm[] = BOARD_LCD_BACKLIGHT_PIN;
00058 
00059 /** Pins to configure for the application. */
00060 static const Pin spi_pins[] = BOARD_LCD_PINS;
00061 
00062 
00063 /*----------------------------------------------------------------------------
00064  *        Local functions
00065  *----------------------------------------------------------------------------*/
00066 
00067 
00068 
00069 
00070 static void ILI9488_InitInterface(void)
00071 {
00072 
00073     PIO_Configure(ILI9488_Reset, PIO_LISTSIZE(ILI9488_Reset));    
00074     PIO_Configure(spi_pins, PIO_LISTSIZE(spi_pins));
00075 
00076 
00077     PIO_Configure(ILI9488_Pwm, PIO_LISTSIZE(ILI9488_Pwm));
00078     /* Enable PWM peripheral clock */
00079     PMC_EnablePeripheral(ID_PWM0);
00080 
00081     /* Set clock A and clock B */
00082     // set for 14.11 KHz for CABC control
00083     //    mode = PWM_CLK_PREB(0x0A) | (PWM_CLK_DIVB(110)) | 
00084     //           PWM_CLK_PREA(0x0A) | (PWM_CLK_DIVA(110));
00085     PWMC_ConfigureClocks(PWM0, 14200, 0,  BOARD_MCK);
00086 
00087     /* Configure PWM channel 1 for LED0  */
00088     PWMC_DisableChannel(PWM0, CHANNEL_PWM_LCD);
00089 
00090     PWMC_ConfigureChannel(PWM0, CHANNEL_PWM_LCD, PWM_CMR_CPRE_CLKA,0,PWM_CMR_CPOL);
00091     PWMC_SetPeriod(PWM0, CHANNEL_PWM_LCD, 16);
00092     PWMC_SetDutyCycle(PWM0, CHANNEL_PWM_LCD, 8);
00093     PWMC_EnableChannel(PWM0, CHANNEL_PWM_LCD);
00094 
00095     SPI_Configure(ILI9488, ILI9488_ID, (SPI_MR_MSTR | SPI_MR_MODFDIS | SPI_PCS( ILI9488_cs )));
00096     SPI_ConfigureNPCS( ILI9488, ILI9488_cs, 
00097             SPI_CSR_CPOL | SPI_CSR_BITS_9_BIT | 
00098             SPI_DLYBS(100, BOARD_MCK) | SPI_DLYBCT(100, BOARD_MCK) |
00099             SPI_SCBR( 35000000, BOARD_MCK) ) ;  
00100 
00101     SPI_Enable(ILI9488);
00102 
00103 }
00104 
00105 /**
00106  * \brief Send Command to ILI9488.
00107  *
00108  * \param reg   Command Register address.
00109  *
00110  */
00111 static void ILI9488_SendCmd( uint8_t reg )
00112 {    
00113     SPI_Write(ILI9488, ILI9488_cs, ILI9488_CMD(reg));  
00114 }
00115 
00116 
00117 
00118 /**
00119  * \brief Write Parameter to ILI9488 Register.
00120  *
00121  * \param data  Data to be written.
00122  */
00123 static void ILI9488_WriteReg( uint8_t data )
00124 {
00125     SPI_Write(ILI9488, ILI9488_cs, ILI9488_PARAM(data));
00126 }
00127 
00128 /**
00129  * \brief Write 16 bit Parameter to ILI9488 Register.
00130  *
00131  * \param data  Data to be written.
00132  */
00133 static void ILI9488_WriteReg16( uint16_t data )
00134 {
00135     SPI_Write(ILI9488, ILI9488_cs, ILI9488_PARAM(((data & 0xFF00) >> 0x08)));
00136     SPI_Write(ILI9488, ILI9488_cs, ILI9488_PARAM((data & 0xFF)));
00137 }
00138 
00139 /**
00140  * \brief Write 24 bit Parameter to ILI9488 Register.
00141  *
00142  * \param data  Data to be written.
00143  */
00144 static void ILI9488_WriteReg24( uint32_t data )
00145 {
00146     SPI_Write(ILI9488, ILI9488_cs, ILI9488_PARAM(((data & 0xFF0000) >> 0x10)));
00147     SPI_Write(ILI9488, ILI9488_cs, ILI9488_PARAM(((data & 0xFF00) >> 0x08)));
00148     SPI_Write(ILI9488, ILI9488_cs, ILI9488_PARAM((data & 0xFF)));
00149 }
00150 
00151 /**
00152  * \brief Write 32 bit Parameter to ILI9488 Register.
00153  *
00154  * \param data  Data to be written.
00155  */
00156 static void ILI9488_WriteReg32( uint32_t data )
00157 {
00158     SPI_Write(ILI9488, ILI9488_cs, ILI9488_PARAM((data >> 0x18) & 0xFF));
00159     SPI_Write(ILI9488, ILI9488_cs, ILI9488_PARAM(((data >> 0x10) & 0x00FF)));
00160     SPI_Write(ILI9488, ILI9488_cs, ILI9488_PARAM(((data >> 0x08) & 0x0000FF)));
00161     SPI_Write(ILI9488, ILI9488_cs, ILI9488_PARAM((data & 0x000000FF)));
00162 }
00163 
00164 /**
00165  * \brief Read data from ILI9488 Register.
00166  *
00167  * \param reg   Register address.
00168  *
00169  * \return      Read data.
00170  */
00171 static uint8_t ILI9488_ReadReg( uint8_t reg)
00172 {
00173     uint8_t value;
00174 
00175     SPI_Write(ILI9488, ILI9488_cs, ILI9488_CMD(reg));
00176     while(SPI_IsFinished(ILI9488) !=1);
00177     SPI_Read(ILI9488);
00178     SPI_Write(ILI9488, ILI9488_cs, ILI9488_PARAM(0xFF));
00179     while(SPI_IsFinished(ILI9488) !=1);
00180     value = (uint8_t)SPI_Read(ILI9488);
00181 
00182     ILI9488_SendCmd(ILI9488_CMD_SPI_READ_SETTINGS);
00183     ILI9488_WriteReg(0);
00184 
00185     return value;
00186 
00187 }    
00188 /**
00189  * \brief Read data from ILI9488 Register.
00190  *
00191  * \param reg   Register address.
00192  *
00193  * \return      Read data.
00194  */
00195 static uint16_t ILI9488_ReadReg16( uint8_t reg)
00196 {
00197     uint16_t value;
00198     uint8_t SPI_CNT = 0x81;
00199 
00200     ILI9488_SendCmd(ILI9488_CMD_SPI_READ_SETTINGS);
00201     ILI9488_WriteReg(SPI_CNT);         
00202     value = (ILI9488_ReadReg(reg) << 0x08);
00203 
00204     SPI_CNT++;
00205     ILI9488_SendCmd(ILI9488_CMD_SPI_READ_SETTINGS);
00206     ILI9488_WriteReg(SPI_CNT);  
00207     value |= ILI9488_ReadReg(reg);
00208 
00209     ILI9488_SendCmd(ILI9488_CMD_SPI_READ_SETTINGS);
00210     ILI9488_WriteReg(0);
00211 
00212     return value;
00213 
00214 }
00215 
00216 /**
00217  * \brief Read data from ILI9488 Register.
00218  *
00219  * \param reg   Register address.
00220  *
00221  * \return      Read data.
00222  */
00223 static uint32_t ILI9488_ReadReg24( uint8_t reg)
00224 {
00225     uint32_t value=0;
00226     uint8_t SPI_CNT = 0x81;
00227 
00228     //Set ILI9488 count to 0
00229     ILI9488_SendCmd(ILI9488_CMD_SPI_READ_SETTINGS);
00230     ILI9488_WriteReg(SPI_CNT);
00231 
00232     // Send Command
00233     value = (ILI9488_ReadReg(reg) << 0x10);
00234 
00235     SPI_CNT++;
00236     ILI9488_SendCmd(ILI9488_CMD_SPI_READ_SETTINGS);
00237     ILI9488_WriteReg(SPI_CNT);  
00238 
00239     value |= (ILI9488_ReadReg(reg) << 0x08);
00240 
00241     SPI_CNT++;
00242     ILI9488_SendCmd(ILI9488_CMD_SPI_READ_SETTINGS);
00243     ILI9488_WriteReg(SPI_CNT);  
00244     value |= ILI9488_ReadReg(reg);
00245 
00246     ILI9488_SendCmd(ILI9488_CMD_SPI_READ_SETTINGS);
00247     ILI9488_WriteReg(0);
00248 
00249 
00250     return value;
00251 
00252 
00253 }
00254 
00255 /**
00256  * \brief Read data from ILI9488 Register.
00257  *
00258  * \param reg   Register address.
00259  *
00260  * \return      Read data.
00261  */
00262 static uint32_t ILI9488_ReadReg32( uint8_t reg)
00263 {
00264     uint32_t value;
00265     uint8_t SPI_CNT = 0x81;
00266 
00267     ILI9488_SendCmd(ILI9488_CMD_SPI_READ_SETTINGS);
00268     ILI9488_WriteReg(SPI_CNT);
00269     value = ILI9488_ReadReg(reg) ;
00270     value  <<=  24;
00271 
00272     SPI_CNT++;
00273     ILI9488_SendCmd(ILI9488_CMD_SPI_READ_SETTINGS);
00274     ILI9488_WriteReg(SPI_CNT);  
00275     value |= (ILI9488_ReadReg(reg) << 16);
00276 
00277     SPI_CNT++;
00278     ILI9488_SendCmd(ILI9488_CMD_SPI_READ_SETTINGS);
00279     ILI9488_WriteReg(SPI_CNT);  
00280     value |= (ILI9488_ReadReg(reg) << 8);
00281 
00282     SPI_CNT++;
00283     ILI9488_SendCmd(ILI9488_CMD_SPI_READ_SETTINGS);
00284     ILI9488_WriteReg(SPI_CNT);  
00285     value |= ILI9488_ReadReg(reg);
00286 
00287     ILI9488_SendCmd(ILI9488_CMD_SPI_READ_SETTINGS);
00288     ILI9488_WriteReg(0);
00289 
00290     return value;
00291 }
00292 
00293 static void ILI9488_NOP(void)
00294 {
00295     ILI9488_SendCmd(ILI9488_CMD_NOP);
00296 }
00297 
00298 
00299 
00300 
00301 
00302 /**
00303  * \brief Write data to ILI9488 Register.
00304  *
00305  * \param reg   Register address.
00306  * \param data  Data to be written.
00307  */
00308 void ILI9488_WriteSingle( LcdColor_t data )
00309 {
00310 
00311 
00312     ILI9488_SendCmd(ILI9488_CMD_MEMORY_WRITE);
00313     ILI9488_WriteReg24(data);
00314 
00315 }
00316 
00317 /**
00318  * \brief Prepare to write data to ILI9488 Register.
00319  *
00320  */
00321 void ILI9488_WriteRAM_Prepare(void)
00322 {
00323     ILI9488_SendCmd(ILI9488_CMD_MEMORY_WRITE);
00324 }
00325 
00326 /**
00327  * \brief Prepare to write data to ILI9488 Register.
00328  *
00329  */
00330 void ILI9488_ReadRAM_Prepare(void)
00331 {
00332     ILI9488_SendCmd(ILI9488_CMD_MEMORY_READ);
00333 }
00334 
00335 /**
00336  * \brief Write data to ILI9488 Register.
00337  *
00338  * \param reg   Register address.
00339  * \param data  Data to be written.
00340  */
00341 void ILI9488_WriteRAM( LcdColor_t data )
00342 {  
00343     ILI9488_WriteReg24(data);  
00344 }
00345 
00346 
00347 /**
00348  * \brief Write data to ILI9488 Register.
00349  *
00350  * \param reg   Register address.
00351  * \param data  Data to be written.
00352  */
00353 void ILI9488_WriteRAMBuffer( const LcdColor_t *pBuf, uint32_t size)
00354 {
00355     uint32_t addr ;
00356 
00357 
00358     for ( addr = 0 ; addr < size ; addr++ )
00359     {
00360         ILI9488_WriteRAM(pBuf[addr]);
00361     }
00362 }
00363 
00364 void ILI9488_SetCursor(uint16_t x, uint16_t y)
00365 {
00366     /* Set Horizontal Address Start Position */
00367     ILI9488_SendCmd(ILI9488_CMD_COLUMN_ADDRESS_SET);    
00368     ILI9488_WriteReg16(x);
00369     ILI9488_WriteReg16(x+1);
00370     ILI9488_NOP();
00371 
00372 
00373     /* Set Horizontal Address End Position */
00374     ILI9488_SendCmd(ILI9488_CMD_PAGE_ADDRESS_SET);
00375     ILI9488_WriteReg16(y);
00376     ILI9488_WriteReg16(y+1);
00377     ILI9488_NOP();
00378 }
00379 
00380 
00381 
00382 /**
00383  * \brief Initialize the ILI9488 controller.
00384  */
00385 extern uint32_t ILI9488_Initialize( void )
00386 {
00387     uint32_t chipid;
00388 
00389     ILI9488_InitInterface();
00390 
00391     ILI9488_SendCmd(ILI9488_CMD_SOFTWARE_RESET);    
00392     Wait(200);
00393 
00394     ILI9488_SendCmd(ILI9488_CMD_SLEEP_OUT);
00395     Wait(200);
00396 
00397     // make it tRGB and reverse the column order
00398     ILI9488_SendCmd(ILI9488_CMD_MEMORY_ACCESS_CONTROL);
00399     ILI9488_WriteReg(0x48);
00400     Wait(100);
00401 
00402     ILI9488_SendCmd(ILI9488_CMD_CABC_CONTROL_9); // set PWm to 14.11 KHz
00403     ILI9488_WriteReg(0x04);
00404 
00405     //    ILI9488_SendCmd(ILI9488_CMD_COLMOD_PIXEL_FORMAT_SET); // set 16bit/pixel
00406     //    ILI9488_WriteReg(0x05);
00407 
00408     /* Check ILI9488 chipID */
00409     chipid = ILI9488_ReadReg24(ILI9488_CMD_READ_ID4); /* Driver Code Read  */
00410     if ( chipid != ILI9488_DEVICE_CODE )
00411     {
00412         printf( "Read ILI9488 chip ID (0x%04x) error, skip initialization.\r\n", chipid ) ;
00413         assert(0);
00414         return 1 ;
00415     }
00416 
00417     ILI9488_SendCmd(ILI9488_CMD_NORMAL_DISP_MODE_ON);
00418     ILI9488_SendCmd(ILI9488_CMD_DISPLAY_ON);
00419 
00420     return 0 ;
00421 }
00422 
00423 
00424 
00425 
00426 /**
00427  * \brief Turn on the ILI9488.
00428  */
00429 extern void ILI9488_On( void )
00430 {
00431     ILI9488_SendCmd(ILI9488_CMD_PIXEL_OFF);
00432     ILI9488_SendCmd(ILI9488_CMD_DISPLAY_ON);
00433     ILI9488_SendCmd(ILI9488_CMD_NORMAL_DISP_MODE_ON);
00434 }
00435 
00436 
00437 /**
00438  * \brief Turn off the ILI9488.
00439  */
00440 extern void ILI9488_Off( void )
00441 {    
00442     ILI9488_SendCmd(ILI9488_CMD_DISPLAY_OFF);
00443     ILI9488_SendCmd(ILI9488_CMD_DISPLAY_OFF);
00444 }
00445 
00446 /**
00447  * \brief Power down the ILI9488.
00448  */
00449 extern void ILI9488_PowerDown( void )
00450 {
00451 
00452 }
00453 
00454 
00455 
00456 
00457 /**
00458  * \brief Set a partial display window
00459  *
00460  * Initialize a partial window on ILI9488
00461  * \param Start Starting address of window.
00462  * \param End  End address of window.
00463  * \return 0 for successful operation.
00464  */
00465 extern void ILI9488_SetPartialWindow( uint16_t Start, uint16_t End)
00466 {
00467 
00468     ILI9488_SendCmd(ILI9488_CMD_POWER_CONTROL_PARTIAL_5);
00469     ILI9488_WriteReg(0x44 ) ;
00470 
00471     ILI9488_SendCmd(ILI9488_CMD_PARTIAL_AREA);
00472     ILI9488_WriteReg16(Start ) ;
00473     ILI9488_WriteReg16(End)  ;
00474 
00475     ILI9488_SendCmd(ILI9488_CMD_PARTIAL_MODE_ON);
00476     Wait(10);
00477 
00478 
00479 }
00480 
00481 
00482 
00483 extern void ILI9488_SetWindow( uint16_t dwX, uint16_t dwY, uint16_t dwWidth, uint16_t dwHeight )
00484 {
00485     uint16_t ColStart, ColEnd, RowStart, RowEnd;
00486 
00487     ColStart  =  dwX ;
00488     ColEnd    =  dwWidth;
00489 
00490     RowStart = dwY ;
00491     RowEnd   = dwHeight;
00492 
00493     if (  ( ColEnd > (ILI9488_LCD_WIDTH)) || ( RowEnd > (ILI9488_LCD_HEIGHT))) 
00494     {
00495         printf("\n\rWindow too large\n\r");
00496         assert(1);
00497     }
00498 
00499     if (  ( ColEnd < ColStart) || ( RowEnd < RowStart) )
00500     {
00501         printf("\n\rWindow's hight or width is not large enough\n\r");
00502         assert(1);     
00503     }
00504     /* Set Horizontal Address Start Position */
00505     ILI9488_SendCmd(ILI9488_CMD_COLUMN_ADDRESS_SET);    
00506     ILI9488_WriteReg16(ColStart);
00507     ILI9488_WriteReg16(ColEnd);
00508     ILI9488_NOP();
00509 
00510 
00511     /* Set Horizontal Address End Position */
00512     ILI9488_SendCmd(ILI9488_CMD_PAGE_ADDRESS_SET);
00513     ILI9488_WriteReg16(RowStart);
00514     ILI9488_WriteReg16(RowEnd);
00515     ILI9488_NOP();
00516 
00517 }
00518 
00519 extern void ILI9488_SetDisplayLandscape( uint8_t dwRGB, uint8_t LandscaprMode )
00520 {
00521     uint8_t Value;
00522     if(LandscaprMode)
00523     {
00524         if(dwRGB)
00525         {
00526             Value = 0xA8;
00527         }
00528         else
00529         {
00530             Value = 0xA0;
00531         }
00532     }
00533     else
00534     {
00535         if(dwRGB)
00536         {
00537             Value = 0xE8;
00538         }
00539         else
00540         {
00541             Value = 0xE0;
00542         }
00543     }
00544     // make it tRGB and reverse the column order
00545     ILI9488_SendCmd(ILI9488_CMD_MEMORY_ACCESS_CONTROL);
00546     ILI9488_WriteReg(Value);
00547     Wait(50);
00548 
00549     ILI9488_SetWindow( 0, 0, BOARD_LCD_WIDTH, BOARD_LCD_HEIGHT  ) ;
00550 }
00551 
00552 extern void ILI9488_SetDisplayPortrait( uint8_t dwRGB )
00553 {
00554     uint8_t Value;
00555     if(dwRGB)
00556     {
00557         Value = 0x48;
00558     }
00559     else
00560     {
00561         Value = 0x40;
00562     }
00563     // make it tRGB and reverse the column order
00564     ILI9488_SendCmd(ILI9488_CMD_MEMORY_ACCESS_CONTROL);
00565     ILI9488_WriteReg(Value);
00566     Wait(50);
00567 
00568     ILI9488_SetWindow( 0, 0, BOARD_LCD_WIDTH, BOARD_LCD_HEIGHT) ;
00569 }
00570 
00571 
00572 extern void ILI9488_SetVerticalScrollWindow( uint16_t dwStartAdd, uint16_t dwHeight )
00573 {
00574     ILI9488_SendCmd(ILI9488_CMD_VERT_SCROLL_DEFINITION);
00575     ILI9488_WriteReg16(dwStartAdd-1);
00576     ILI9488_WriteReg16(dwStartAdd);
00577     ILI9488_WriteReg16((dwStartAdd + dwHeight + 1));
00578 }
00579 
00580 
00581 extern void ILI9488_VerticalScroll( uint16_t wY )
00582 {
00583     ILI9488_SendCmd(ILI9488_CMD_VERT_SCROLL_START_ADDRESS);
00584     ILI9488_WriteReg16(wY);
00585 }
00586 
00587 
00588 
00589 extern void ILI9488_ExitScrollMode(void )
00590 {
00591     ILI9488_SendCmd(ILI9488_CMD_DISPLAY_OFF);
00592     ILI9488_SendCmd(ILI9488_CMD_NORMAL_DISP_MODE_ON);
00593     ILI9488_SendCmd(ILI9488_CMD_DISPLAY_ON);
00594 }
00595 
00596 
00597 extern void ILI9488_TestPattern(void)
00598 {
00599     uint32_t i, data;
00600 
00601     ILI9488_SetWindow( 0, 0, 319, 479 ) ;  
00602 
00603     data = COLOR_WHITE;
00604     ILI9488_SendCmd(ILI9488_CMD_MEMORY_WRITE);
00605     for(i = 0; i< (BOARD_LCD_WIDTH * BOARD_LCD_HEIGHT); i++)
00606     {
00607         SPI_Write(ILI9488, ILI9488_cs, ILI9488_PARAM(data >> 16));
00608         SPI_Write(ILI9488, ILI9488_cs, ILI9488_PARAM(data >> 8));
00609         SPI_Write(ILI9488, ILI9488_cs, ILI9488_PARAM(data & 0xFF));
00610     }
00611 
00612     ILI9488_SetWindow( 50, 50, 300, 300 ) ;  
00613     data = COLOR_BLUE;
00614     ILI9488_SendCmd(ILI9488_CMD_MEMORY_WRITE);
00615     for(i = 0; i< (BOARD_LCD_WIDTH * BOARD_LCD_HEIGHT); i++)
00616     {
00617         SPI_Write(ILI9488, ILI9488_cs, ILI9488_PARAM(data >> 16));
00618         SPI_Write(ILI9488, ILI9488_cs, ILI9488_PARAM(data >> 8));
00619         SPI_Write(ILI9488, ILI9488_cs, ILI9488_PARAM(data & 0xFF));
00620     }
00621 
00622     ILI9488_SetWindow( 150, 150, 300, 300 ) ;  
00623     data = COLOR_GREEN;
00624     ILI9488_SendCmd(ILI9488_CMD_MEMORY_WRITE);
00625     for(i = 0; i< (BOARD_LCD_WIDTH * BOARD_LCD_HEIGHT); i++)
00626     {
00627         SPI_Write(ILI9488, ILI9488_cs, ILI9488_PARAM(data >> 16));
00628         SPI_Write(ILI9488, ILI9488_cs, ILI9488_PARAM(data >> 8));
00629         SPI_Write(ILI9488, ILI9488_cs, ILI9488_PARAM(data & 0xFF));
00630     }
00631 
00632     ILI9488_SetWindow(200, 200, 300, 300 ) ;  
00633     data = COLOR_RED;
00634     ILI9488_SendCmd(ILI9488_CMD_MEMORY_WRITE);
00635     for(i = 0; i< (BOARD_LCD_WIDTH * BOARD_LCD_HEIGHT); i++)
00636     {
00637         SPI_Write(ILI9488, ILI9488_cs, ILI9488_PARAM(data >> 16));
00638         SPI_Write(ILI9488, ILI9488_cs, ILI9488_PARAM(data >> 8));
00639         SPI_Write(ILI9488, ILI9488_cs, ILI9488_PARAM(data & 0xFF));
00640     }
00641 
00642 }
00643 
00644 #endif
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Defines