00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042 #include "board.h"
00043
00044 #include <stdint.h>
00045 #include <string.h>
00046 #include <assert.h>
00047
00048
00049
00050
00051 static void* gpCanvasBuffer = NULL;
00052 static uint32_t gwCanvasBufferSize;
00053 static uint32_t gwCanvasMaxWidth, gwCanvasMaxHeight;
00054 extern uint8_t ili9488_lcdMode;
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065 static void LCDD_SetPixelColor(uint32_t x, uint32_t y, uint32_t color)
00066 {
00067 uint8_t txBuf[3];
00068 ILI9488_SpiSetCursor( x, y ) ;
00069
00070 txBuf[0] = (uint8_t)((color & 0xFF0000) >> 0x10);
00071 txBuf[1] = (uint8_t)((color & 0xFF00) >> 0x08);
00072 txBuf[2] = (uint8_t)(color & 0xFF);
00073 ILI9488_SpiSendCommand( ILI9488_CMD_MEMORY_WRITE,
00074 txBuf,
00075 NULL,
00076 AccessWrite,
00077 sizeof(txBuf));
00078 }
00079
00080
00081
00082
00083
00084
00085
00086 static void LCDD_FillSolidRect(uint16_t *pCanvasBuffer, rect rc, uint32_t dwColor )
00087 {
00088 uint32_t row, col;
00089 uint32_t w,h;
00090
00091
00092 w = rc.x + rc.width;
00093 w = w > gwCanvasMaxWidth ? gwCanvasMaxWidth : w;
00094 h = rc.y + rc.height;
00095 h = h > gwCanvasMaxHeight ? gwCanvasMaxHeight : h;
00096
00097 if (ili9488_lcdMode == ILI9488_SPIMODE) {
00098 sBGR *p_buf = gpCanvasBuffer;
00099 if(pCanvasBuffer != NULL) p_buf = (sBGR *)((uint8_t*)pCanvasBuffer);
00100 if(NULL == p_buf) {
00101 for(row = rc.y; row < h; row++) {
00102 for(col = rc.x; col < w; col++) {
00103 LCDD_SetPixelColor(col, row, dwColor);
00104 }
00105 }
00106 return;
00107 }
00108
00109 for(row = rc.y; row < h; row++) {
00110 for(col = rc.x; col < w; col++) {
00111
00112 p_buf[row * gwCanvasMaxWidth + col].b = dwColor&0xFF;
00113 p_buf[row * gwCanvasMaxWidth + col].g = dwColor>>8;
00114 p_buf[row * gwCanvasMaxWidth + col].r = dwColor>>16;
00115 }
00116 }
00117 } else {
00118 uint16_t *p_buf = gpCanvasBuffer;
00119 if(pCanvasBuffer != NULL) p_buf = pCanvasBuffer;
00120
00121 for(row = rc.y; row < h; row++) {
00122 for(col = rc.x; col < w; col++) {
00123 p_buf[row * gwCanvasMaxWidth + col] = (uint16_t)dwColor;
00124 }
00125 }
00126 }
00127 }
00128
00129
00130
00131
00132
00133
00134
00135
00136 void LCDD_SetUpdateWindowSize(rect rc)
00137 {
00138 gwCanvasMaxWidth = rc.width + 1;
00139 gwCanvasMaxHeight = rc.height + 1;
00140 if (ili9488_lcdMode == ILI9488_SPIMODE) {
00141 ILI9488_SpiSetWindow( rc.x, rc.y, rc.width, rc.height);
00142 } else {
00143 ILI9488_EbiSetWindow( rc.x, rc.y, rc.width, rc.height);
00144 }
00145 }
00146
00147
00148
00149
00150 void LCDD_UpdateWindow(void)
00151 {
00152 uint32_t size = 0;
00153 if (ili9488_lcdMode == ILI9488_SPIMODE) {
00154 size = gwCanvasBufferSize / (sizeof(sBGR)) *3 ;
00155 ILI9488_SpiSendCommand(ILI9488_CMD_MEMORY_WRITE,
00156 (uint8_t*)gpCanvasBuffer, 0, AccessWrite, size);
00157 } else {
00158 size = gwCanvasBufferSize / sizeof(uint16_t);
00159 ILI9488_EbiSendCommand(ILI9488_CMD_MEMORY_WRITE,
00160 (uint16_t*)gpCanvasBuffer, 0, AccessWrite, size);
00161 }
00162 }
00163
00164
00165
00166
00167
00168
00169 void LCDD_UpdatePartialWindow(uint8_t* pCanvasBuffer,uint32_t size)
00170 {
00171 uint32_t cnt = 0;
00172 if (ili9488_lcdMode == ILI9488_SPIMODE) {
00173 cnt = size/sizeof(sBGR) * 3;
00174 ILI9488_SpiSendCommand(ILI9488_CMD_MEMORY_WRITE,
00175 (uint8_t*)pCanvasBuffer, 0, AccessWrite, cnt);
00176 } else {
00177 cnt = size/sizeof(uint16_t);
00178 ILI9488_EbiSendCommand(ILI9488_CMD_MEMORY_WRITE,
00179 (uint16_t*)pCanvasBuffer, 0, AccessWrite, cnt);
00180 }
00181 }
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192 void LCDD_DrawRectangleWithFill(uint16_t *pCanvasBuffer, uint32_t dwX, uint32_t dwY, uint32_t dwWidth,
00193 uint32_t dwHeight, uint32_t dwColor)
00194 {
00195 rect rc;
00196 rc.x = dwX;
00197 rc.y = dwY;
00198 rc.width = dwWidth + 1;
00199 rc.height = dwHeight + 1;
00200 LCDD_FillSolidRect(pCanvasBuffer, rc , dwColor);
00201 }
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212 uint32_t LCDD_DrawCircle(uint16_t *pCanvasBuffer, uint32_t x, uint32_t y, uint32_t r, uint32_t color )
00213 {
00214 signed int d;
00215 uint32_t curX;
00216 uint32_t curY;
00217
00218 d = 3 - (r << 1);
00219 curX = 0;
00220 curY = r;
00221
00222 while (curX <= curY) {
00223 LCDD_DrawPixel(pCanvasBuffer, x + curX, y + curY, color);
00224 LCDD_DrawPixel(pCanvasBuffer, x + curX, y - curY, color);
00225 LCDD_DrawPixel(pCanvasBuffer, x - curX, y + curY, color);
00226 LCDD_DrawPixel(pCanvasBuffer, x - curX, y - curY, color);
00227 LCDD_DrawPixel(pCanvasBuffer, x + curY, y + curX, color);
00228 LCDD_DrawPixel(pCanvasBuffer, x + curY, y - curX, color);
00229 LCDD_DrawPixel(pCanvasBuffer, x - curY, y + curX, color);
00230 LCDD_DrawPixel(pCanvasBuffer, x - curY, y - curX, color);
00231
00232 if (d < 0) {
00233 d += (curX << 2) + 6;
00234 } else {
00235 d += ((curX - curY) << 2) + 10;
00236 curY--;
00237 }
00238 curX++;
00239 }
00240 return 0;
00241 }
00242
00243
00244
00245
00246
00247
00248
00249
00250
00251
00252 uint32_t LCD_DrawFilledCircle(uint16_t *pCanvasBuffer, uint32_t dwX, uint32_t dwY,
00253 uint32_t dwRadius, uint32_t color)
00254 {
00255 signed int d;
00256 uint32_t dwCurX;
00257 uint32_t dwCurY;
00258 uint32_t dwXmin, dwYmin;
00259
00260 if (dwRadius == 0) {
00261 return 0;
00262 }
00263 d = 3 - (dwRadius << 1);
00264 dwCurX = 0;
00265 dwCurY = dwRadius;
00266
00267 while ( dwCurX <= dwCurY ) {
00268 dwXmin = (dwCurX > dwX) ? 0 : dwX-dwCurX;
00269 dwYmin = (dwCurY > dwY) ? 0 : dwY-dwCurY;
00270 LCDD_DrawRectangleWithFill(pCanvasBuffer, dwXmin, dwYmin,
00271 dwX + dwCurX - dwXmin, 1 ,color);
00272 LCDD_DrawRectangleWithFill(pCanvasBuffer, dwXmin,
00273 dwY+dwCurY, dwX + dwCurX - dwXmin, 1,
00274 color );
00275 dwXmin = (dwCurY > dwX) ? 0 : dwX-dwCurY;
00276 dwYmin = (dwCurX > dwY) ? 0 : dwY-dwCurX;
00277 LCDD_DrawRectangleWithFill(pCanvasBuffer, dwXmin, dwYmin,
00278 dwX + dwCurY -dwXmin , 1, color );
00279 LCDD_DrawRectangleWithFill(pCanvasBuffer, dwXmin,
00280 dwY + dwCurX, dwX+dwCurY - dwXmin, 1,
00281 color );
00282 if ( d < 0 ) {
00283 d += (dwCurX << 2) + 6;
00284 } else {
00285 d += ((dwCurX - dwCurY) << 2) + 10;
00286 dwCurY--;
00287 }
00288 dwCurX++;
00289 }
00290
00291 return 0;
00292 }
00293
00294
00295
00296
00297
00298
00299
00300
00301
00302
00303 void LCDD_DrawString( uint16_t* pCanvasBuffer, uint32_t x, uint32_t y,
00304 const uint8_t *pString, uint32_t color )
00305 {
00306 uint32_t xorg = x;
00307
00308 while ( *pString != 0 ) {
00309 if ( *pString == '\n' ) {
00310 y += gFont.height + 2;
00311 x = xorg;
00312 } else {
00313 LCDD_DrawChar(pCanvasBuffer, x, y, *pString, color );
00314 x += gFont.width + 2;
00315 }
00316 pString++;
00317 }
00318 }
00319
00320
00321
00322
00323
00324
00325
00326
00327
00328
00329
00330 void LCDD_GetStringSize( const uint8_t *pString, uint32_t *pWidth,
00331 uint32_t *pHeight )
00332 {
00333 uint32_t width = 0;
00334 uint32_t height = gFont.height;
00335
00336 while ( *pString != 0 ) {
00337 if ( *pString == '\n' ) {
00338 height += gFont.height + 2;
00339 } else {
00340 width += gFont.width + 2;
00341 }
00342 pString++;
00343 }
00344
00345 if ( width > 0 ) {
00346 width -= 2;
00347 }
00348
00349 if ( pWidth != NULL ) {
00350 *pWidth = width;
00351 }
00352
00353 if ( pHeight != NULL ) {
00354 *pHeight = height;
00355 }
00356 }
00357
00358
00359
00360
00361
00362
00363
00364
00365
00366
00367
00368
00369
00370
00371
00372
00373
00374 void LCDD_BitBlt( uint16_t* pCanvasBuffer, uint32_t dst_x,uint32_t dst_y,uint32_t dst_w,uint32_t dst_h,
00375 const LcdColor_t *src,
00376 uint32_t src_x,uint32_t src_y,uint32_t src_w,uint32_t src_h)
00377 {
00378 uint32_t row,col;
00379 uint32_t src_row,src_col;
00380
00381
00382 src_h = src_h;
00383 if (ili9488_lcdMode == ILI9488_SPIMODE) {
00384 sBGR *p_buf = gpCanvasBuffer;
00385 if(pCanvasBuffer != NULL) p_buf = (sBGR *)((uint8_t*)pCanvasBuffer);
00386
00387 SCB_CleanInvalidateDCache();
00388 for(src_row = src_y,row = dst_y; row < dst_h; row++,src_row++) {
00389 for(src_col = src_x,col = dst_x; col < dst_w; col++,src_col++) {
00390 p_buf[row * gwCanvasMaxWidth+col].r = src[src_row*src_w + src_col]&0xFF;
00391 p_buf[row * gwCanvasMaxWidth+col].g = src[src_row*src_w + src_col]>>8;
00392 p_buf[row * gwCanvasMaxWidth+col].b = src[src_row*src_w + src_col]>>16;
00393 }
00394 memory_barrier()
00395 }
00396 memory_barrier()
00397 } else {
00398 uint16_t *p_buf = gpCanvasBuffer;
00399 if(pCanvasBuffer != NULL) p_buf = pCanvasBuffer;
00400
00401 SCB_CleanInvalidateDCache();
00402 for(src_row = src_y,row = dst_y; row < dst_h; row++,src_row++) {
00403 for(src_col = src_x, col = dst_x; col < dst_w; col++,src_col++) {
00404 p_buf[row * gwCanvasMaxWidth+col] = src[src_row*src_w + src_col];
00405 }
00406 }
00407 memory_barrier()
00408 }
00409 }
00410
00411
00412
00413
00414
00415
00416
00417
00418
00419
00420
00421
00422
00423
00424
00425
00426
00427
00428 void LCDD_BitBltAlphaBlend(uint16_t* pCanvasBuffer,
00429 uint32_t dst_x,
00430 uint32_t dst_y,
00431 uint32_t dst_w,
00432 uint32_t dst_h,
00433 const LcdColor_t *src,
00434 uint32_t src_x,
00435 uint32_t src_y,
00436 uint32_t src_w,
00437 uint32_t src_h,
00438 uint32_t alpha)
00439 {
00440 uint32_t row,col;
00441 uint32_t src_row,src_col;
00442 uint32_t w,h;
00443 uint32_t dst_row;
00444 uint32_t r,g,b;
00445
00446 if (ili9488_lcdMode == ILI9488_SPIMODE) {
00447 sBGR *p_buf = gpCanvasBuffer;
00448 if(pCanvasBuffer != NULL) p_buf = (sBGR *)((uint8_t*)pCanvasBuffer);
00449
00450
00451 SCB_CleanInvalidateDCache();
00452 for(src_row = src_y,row = dst_y; row < dst_h; row++,src_row++) {
00453 for(src_col = src_x,col = dst_x; col < dst_w; col++,src_col++) {
00454 p_buf[row *dst_w +col].r = src[src_row*src_w + src_col]&0xFF;
00455 p_buf[row *dst_w +col].g = src[src_row*src_w + src_col]>>8;
00456 p_buf[row *dst_w +col].b = src[src_row*src_w + src_col]>>16;
00457 }
00458 }
00459 memory_barrier()
00460 } else {
00461 uint16_t *p_buf = gpCanvasBuffer;
00462 if(pCanvasBuffer != NULL) p_buf = pCanvasBuffer;
00463 w = src_x + src_w;
00464 h = src_y + src_h;
00465 dst_row = dst_y;
00466 p_buf += (dst_row*dst_w + dst_x);
00467 src += src_y*w + src_x;
00468 SCB_CleanInvalidateDCache();
00469 for(src_row = src_y; src_row < h; src_row++,dst_row++) {
00470 for(src_col = src_x; src_col < w; src_col++){
00471 r = (p_buf[src_col] >> 11) * (255 - alpha) / 255 +
00472 (src[src_col] >> 11) * alpha / 255;
00473 if(r > 0x1F) r = 0x1F;
00474 g = ((p_buf[src_col] >> 5) & 0x3F) * (255 - alpha) / 255 +
00475 ((src[src_col] >> 5) & 0x3f) * alpha / 255;
00476 if(g > 0x3F) g = 0x3F;
00477 b = ((p_buf[src_col]) & 0x1F) * (255 - alpha) / 255
00478 + ((src[src_col]) & 0x1f) * alpha / 255;
00479 if(b > 0x1F) b = 0x1F;
00480 p_buf[src_col] = ((r & 0x1F) << 11)|((g & 0x3F) << 5)|( b & 0x1F);
00481 }
00482 p_buf += dst_w;
00483 src += w;
00484 }
00485 memory_barrier()
00486 }
00487 }
00488
00489
00490
00491
00492
00493
00494
00495
00496
00497
00498
00499 void LCDD_DrawImage(uint16_t* pCanvasBuffer, uint32_t dwX, uint32_t dwY,
00500 const LcdColor_t *pImage, uint32_t dwWidth, uint32_t dwHeight )
00501 {
00502
00503
00504
00505
00506 LCDD_BitBlt(pCanvasBuffer, dwX, dwY, dwWidth, dwHeight,
00507 pImage, 0, 0, dwWidth - dwX, dwHeight - dwY);
00508 }
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518 void LCDD_DrawPixel(uint16_t* pCanvasBuffer, uint32_t x, uint32_t y, uint32_t color )
00519 {
00520
00521 if (ili9488_lcdMode == ILI9488_SPIMODE) {
00522 sBGR *p_buf = gpCanvasBuffer;
00523 if(pCanvasBuffer != NULL) p_buf = (sBGR *)((uint8_t*)pCanvasBuffer);
00524 if(NULL == p_buf){
00525 LCDD_SetPixelColor(x, y, color);
00526 return;
00527 }
00528 p_buf += y * gwCanvasMaxWidth;
00529 p_buf += x;
00530 p_buf->b = color&0xFF;
00531 p_buf->g = color>>8;
00532 p_buf->r = color>>16;
00533 p_buf++;
00534 memory_barrier()
00535 } else {
00536 uint16_t *p_buf = gpCanvasBuffer;
00537 if(pCanvasBuffer != NULL) p_buf = pCanvasBuffer;
00538 p_buf += y * gwCanvasMaxWidth;
00539 p_buf += x;
00540 *p_buf = (uint16_t)color;
00541 }
00542 }
00543
00544
00545
00546
00547
00548
00549
00550
00551
00552
00553
00554 void LCDD_DrawLine(uint16_t* pCanvasBuffer, uint32_t dwX1, uint32_t dwY1,
00555 uint32_t dwX2, uint32_t dwY2 , uint32_t color )
00556 {
00557 if (( dwY1 == dwY2 ) || (dwX1 == dwX2)) {
00558
00559 LCDD_DrawStraightLine(pCanvasBuffer, dwX1, dwY1, dwX2, dwY2, color );
00560 } else {
00561 LCDD_DrawLineBresenham(pCanvasBuffer, dwX1, dwY1, dwX2, dwY2 , color);
00562 }
00563 }
00564
00565 void LCDD_DrawStraightLine(uint16_t* pCanvasBuffer, uint32_t dwX1, uint32_t dwY1,
00566 uint32_t dwX2, uint32_t dwY2 , uint32_t color )
00567 {
00568 uint32_t x,y;
00569 uint32_t tmp;
00570
00571 if(dwY1 > dwY2)
00572 {
00573 tmp = dwY1;
00574 dwY1 = dwY2;
00575 dwY2 = tmp;
00576 }
00577 if(dwX1 > dwX2)
00578 {
00579 tmp = dwX1;
00580 dwX1 = dwX2;
00581 dwX2 = tmp;
00582 }
00583 for(y = dwY1; y<=dwY2; y++)
00584 {
00585 for(x=dwX1;x<=dwX2;x++)
00586 {
00587 LCDD_DrawPixel(pCanvasBuffer, x , y , color);
00588 }
00589 }
00590 }
00591
00592
00593
00594
00595
00596
00597
00598
00599
00600
00601
00602 uint32_t LCDD_DrawLineBresenham(uint16_t* pCanvasBuffer, uint32_t dwX1,
00603 uint32_t dwY1, uint32_t dwX2, uint32_t dwY2 , uint32_t color)
00604 {
00605 int dx, dy;
00606 int i;
00607 int xinc, yinc, cumul;
00608 int x, y;
00609
00610 x = dwX1;
00611 y = dwY1;
00612 dx = dwX2 - dwX1;
00613 dy = dwY2 - dwY1;
00614
00615 xinc = ( dx > 0 ) ? 1 : -1;
00616 yinc = ( dy > 0 ) ? 1 : -1;
00617 dx = ( dx > 0 ) ? dx : -dx;
00618 dy = ( dy > 0 ) ? dy : -dy;
00619
00620 LCDD_DrawPixel(pCanvasBuffer, x , y , color);
00621
00622 if ( dx > dy ) {
00623 cumul = dx / 2;
00624 for ( i = 1; i <= dx; i++ ) {
00625 x += xinc;
00626 cumul += dy;
00627
00628 if ( cumul >= dx ) {
00629 cumul -= dx;
00630 y += yinc;
00631 }
00632 LCDD_DrawPixel(pCanvasBuffer, x , y , color);
00633 }
00634 } else {
00635 cumul = dy / 2;
00636 for ( i = 1; i <= dy; i++ ) {
00637 y += yinc;
00638 cumul += dx;
00639
00640 if ( cumul >= dy ) {
00641 cumul -= dy;
00642 x += xinc;
00643 }
00644 LCDD_DrawPixel(pCanvasBuffer, x , y , color);
00645 }
00646 }
00647
00648 return 0;
00649 }
00650
00651
00652
00653
00654
00655
00656
00657
00658
00659
00660
00661 void LCDD_DrawRectangle(uint16_t* pCanvasBuffer, uint32_t x, uint32_t y,
00662 uint32_t width, uint32_t height, uint32_t color )
00663 {
00664 LCDD_DrawRectangleWithFill(pCanvasBuffer, x, y, width, 1, color);
00665 LCDD_DrawRectangleWithFill(pCanvasBuffer, x, y, 1, height, color);
00666
00667 LCDD_DrawRectangleWithFill(pCanvasBuffer, x + width , y, 1, height, color);
00668 LCDD_DrawRectangleWithFill(pCanvasBuffer, x, y + height, width, 1, color);
00669 }
00670
00671
00672
00673
00674
00675
00676
00677 void LCDD_SetCavasBuffer( void* pCanvasBuffer, uint32_t wBufferSize)
00678 {
00679 if (ili9488_lcdMode == ILI9488_SPIMODE) {
00680 gpCanvasBuffer = (sBGR*)pCanvasBuffer;
00681 gwCanvasBufferSize = wBufferSize;
00682 } else {
00683 gpCanvasBuffer = (uint16_t*)pCanvasBuffer;
00684 gwCanvasBufferSize = wBufferSize;
00685 }
00686 }
00687
00688