Demo of 4DGL library for the uLCD-144-G2 128 by 128 color display. See https://mbed.org/users/4180_1/notebook/ulcd-144-g2-128-by-128-color-lcd/ for instructions

Dependencies:   4DGL-uLCD-SE mbed

Fork of uVGAII_demo by jim hamblen

The uLCD-144-G2 from 4D Systems is a low-cost ($25 qty. 100) smart color LCD display board with a serial interface. They are also available from Sparkfun. It looks like a nice alternative to the now hard to find Nokia 6100 LCD breakout boards. It has a TTL level serial interface and a reset pin. An optional uSD card inserted in the display module's socket can be used to load fonts, images, and play videos in response to serial commands. It has a built in system font and the driver supports the use of printfs, so it is very easy to use and hookup. Here is the wiring for the demo program:

mbeduLCD HeaderuLCD cable
5V=VU5V5V
GndGndGnd
TX=P9RXTX
RX=P10TXRX
P11ResetReset

/media/uploads/4180_1/ulcdpins.jpg

In the drawing above, the pins are labeled from the LCDs perspective with TX and RX pins. Mbed RX goes to LCD TX and mbed TX goes to LCD RX. So mbed TX goes to the middle pin on the connector which is the uVGA II RX pin. The included cable seen below is plugged into the bottom row of pins and plugged into a breadboard using the male header pins for hookup. Note that on the cable silkscreen seen in the image below RX and TX have been swapped to indicate the connections needed to the microprocessor pins.

/media/uploads/4180_1/150mm_5_way_female-female_jumper_cable_dsc_2303.jpg /media/uploads/4180_1/5_way_male-male_adaptor_dsc_2299.jpg

// uLCD-144-G2 basic text demo program for uLCD-4GL LCD driver library
//
#include "mbed.h"
#include "uLCD_4DGL.h"

uLCD_4DGL uLCD(p9,p10,p11); // serial tx, serial rx, reset pin;

int main()
{
    // basic printf demo = 16 by 18 characters on screen
    uLCD.printf("\nHello uLCD World\n"); //Default Green on black text
    uLCD.printf("\n  Starting Demo...");
    uLCD.text_width(4); //4X size text
    uLCD.text_height(4);
    uLCD.color(RED);
    for (int i=10; i>=0; --i) {
        uLCD.locate(1,2);
        uLCD.printf("%2D",i);
        wait(.5);
    }
}


Video of longer demo code with both text and graphics. A micro SD card on the LCD module is required for the images and videos seen at the end of the video. The display is actually a bit more colorful and clearer than it appears in the video. Demos include text using printfs, basic graphics commands, a simple bouncing ball animation, computing the Mandelbrot set pixel by pixel, a Plasma wave BLIT, a JPEG image, and a *.wmv video clip.

See https://mbed.org/users/4180_1/notebook/ulcd-144-g2-128-by-128-color-lcd/ for complete info, wiring, breadboard hints on avoiding the use of the cable, and how to work with fonts, images, and videos on the uSD card

Committer:
4180_1
Date:
Wed Nov 20 03:26:19 2013 +0000
Revision:
5:a1ef40ff0f78
Parent:
4:25a266a74a4c
Child:
6:f752accd632c
ver1.3

Who changed what in which revision?

UserRevisionLine numberNew contents of line
4180_1 0:cfcf73272647 1 //
4180_1 0:cfcf73272647 2 // TFT_4DGL is a class to drive 4D Systems TFT touch screens
4180_1 0:cfcf73272647 3 //
4180_1 0:cfcf73272647 4 // Copyright (C) <2010> Stephane ROCHON <stephane.rochon at free.fr>
4180_1 0:cfcf73272647 5 //
4180_1 0:cfcf73272647 6 // TFT_4DGL is free software: you can redistribute it and/or modify
4180_1 0:cfcf73272647 7 // it under the terms of the GNU General Public License as published by
4180_1 0:cfcf73272647 8 // the Free Software Foundation, either version 3 of the License, or
4180_1 0:cfcf73272647 9 // (at your option) any later version.
4180_1 0:cfcf73272647 10 //
4180_1 0:cfcf73272647 11 // TFT_4DGL is distributed in the hope that it will be useful,
4180_1 0:cfcf73272647 12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
4180_1 0:cfcf73272647 13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
4180_1 0:cfcf73272647 14 // GNU General Public License for more details.
4180_1 0:cfcf73272647 15 //
4180_1 0:cfcf73272647 16 // You should have received a copy of the GNU General Public License
4180_1 0:cfcf73272647 17 // along with TFT_4DGL. If not, see <http://www.gnu.org/licenses/>.
4180_1 0:cfcf73272647 18
4180_1 0:cfcf73272647 19 #include "mbed.h"
4180_1 2:75727e89a717 20 #include "uLCD_4DGL.h"
4180_1 0:cfcf73272647 21
4180_1 2:75727e89a717 22 #define SIZE_X 128
4180_1 2:75727e89a717 23 #define SIZE_Y 128
4180_1 1:38ef731c7bdf 24 //
4180_1 1:38ef731c7bdf 25
4180_1 2:75727e89a717 26 uLCD_4DGL uLCD(p9,p10,p11); // serial tx, serial rx, reset pin;
4180_1 0:cfcf73272647 27
4180_1 2:75727e89a717 28 int main()
4180_1 2:75727e89a717 29 {
4180_1 5:a1ef40ff0f78 30 int pixelcolors[40][40];
4180_1 3:454d1f4c8fd7 31 // basic printf demo = 16 by 18 characters on screen
4180_1 3:454d1f4c8fd7 32 uLCD.printf("\nHello uLCD World\n"); //Default Green on black text
4180_1 3:454d1f4c8fd7 33 uLCD.printf("\n Starting Demo...");
4180_1 3:454d1f4c8fd7 34 uLCD.text_width(4); //4X size text
4180_1 3:454d1f4c8fd7 35 uLCD.text_height(4);
4180_1 3:454d1f4c8fd7 36 uLCD.color(RED);
4180_1 3:454d1f4c8fd7 37 for (int i=10; i>=0; --i) {
4180_1 3:454d1f4c8fd7 38 uLCD.locate(1,2);
4180_1 3:454d1f4c8fd7 39 uLCD.printf("%2D",i);
4180_1 3:454d1f4c8fd7 40 wait(.5);
4180_1 3:454d1f4c8fd7 41 }
4180_1 3:454d1f4c8fd7 42 uLCD.cls();
4180_1 3:454d1f4c8fd7 43 uLCD.baudrate(256000); //jack up baud rate to max
4180_1 3:454d1f4c8fd7 44 //demo graphics
4180_1 2:75727e89a717 45 uLCD.background_color(DGREY);
4180_1 2:75727e89a717 46 uLCD.circle(60, 50, 30, 0xFF00FF);
4180_1 2:75727e89a717 47 uLCD.triangle(120, 100, 40, 40, 10, 100, 0x0000FF);
4180_1 2:75727e89a717 48 uLCD.line(0, 0, 80, 60, 0xFF0000);
4180_1 2:75727e89a717 49 uLCD.rectangle(50, 50, 100, 90, 0x00FF00);
4180_1 2:75727e89a717 50 uLCD.pixel(60, 60, BLACK);
4180_1 2:75727e89a717 51 uLCD.read_pixel(120, 70);
4180_1 2:75727e89a717 52 uLCD.circle(120, 60, 10, BLACK);
4180_1 3:454d1f4c8fd7 53 uLCD.set_font(FONT_7X8);
4180_1 2:75727e89a717 54 uLCD.text_mode(TRANSPARENT);
4180_1 2:75727e89a717 55 uLCD.text_char('B', 9, 8, BLACK);
4180_1 2:75727e89a717 56 uLCD.text_char('I',10, 8, BLACK);
4180_1 2:75727e89a717 57 uLCD.text_char('G',11, 8, BLACK);
4180_1 3:454d1f4c8fd7 58 uLCD.text_string("This is a test of string", 1, 4, FONT_7X8, WHITE);
4180_1 3:454d1f4c8fd7 59 wait(2);
4180_1 3:454d1f4c8fd7 60 // printf text only mode demo
4180_1 3:454d1f4c8fd7 61 uLCD.background_color(BLUE);
4180_1 3:454d1f4c8fd7 62 uLCD.cls();
4180_1 3:454d1f4c8fd7 63 uLCD.locate(0,0);
4180_1 3:454d1f4c8fd7 64 uLCD.color(WHITE);
4180_1 3:454d1f4c8fd7 65 uLCD.textbackground_color(BLUE);
4180_1 3:454d1f4c8fd7 66 uLCD.set_font(FONT_7X8);
4180_1 3:454d1f4c8fd7 67 uLCD.text_mode(OPAQUE);
4180_1 3:454d1f4c8fd7 68 int i=0;
4180_1 3:454d1f4c8fd7 69 while(i<64) {
4180_1 3:454d1f4c8fd7 70 if(i%16==0) uLCD.cls();
4180_1 3:454d1f4c8fd7 71 uLCD.printf("TxtLine %2D Page %D\n",i%16,i/16 );
4180_1 3:454d1f4c8fd7 72 i++; //16 lines with 18 charaters per line
4180_1 3:454d1f4c8fd7 73 }
4180_1 5:a1ef40ff0f78 74 //draw an image using BLIT (Block Image Transfer) fastest way to transfer pixel data
4180_1 4:25a266a74a4c 75 uLCD.background_color(BLACK);
4180_1 4:25a266a74a4c 76 uLCD.cls();
4180_1 5:a1ef40ff0f78 77 for(int i=0; i<40; i++) {
4180_1 5:a1ef40ff0f78 78 for(int k=0; k<40; k++) {
4180_1 5:a1ef40ff0f78 79 pixelcolors[i][k] = RED;
4180_1 5:a1ef40ff0f78 80 }
4180_1 4:25a266a74a4c 81 }
4180_1 5:a1ef40ff0f78 82 uLCD.BLIT(50, 50, 40, 40, &pixelcolors[0][0]);
4180_1 4:25a266a74a4c 83 wait(5);
4180_1 3:454d1f4c8fd7 84 //draw an image pixel by pixel
4180_1 3:454d1f4c8fd7 85 uLCD.background_color(BLACK);
4180_1 3:454d1f4c8fd7 86 uLCD.cls();
4180_1 3:454d1f4c8fd7 87 //compute Mandelbrot image for display
4180_1 3:454d1f4c8fd7 88 //image size in pixels and setup
4180_1 3:454d1f4c8fd7 89 const unsigned ImageHeight=128;
4180_1 3:454d1f4c8fd7 90 const unsigned ImageWidth=128;
4180_1 3:454d1f4c8fd7 91 double MinRe = -0.75104;
4180_1 3:454d1f4c8fd7 92 double MaxRe = -0.7408;
4180_1 3:454d1f4c8fd7 93 double MinIm = 0.10511;
4180_1 3:454d1f4c8fd7 94 double MaxIm = MinIm+(MaxRe-MinRe)*ImageHeight/ImageWidth;
4180_1 3:454d1f4c8fd7 95 double Re_factor = (MaxRe-MinRe)/(ImageWidth-1);
4180_1 3:454d1f4c8fd7 96 double Im_factor = (MaxIm-MinIm)/(ImageHeight-1);
4180_1 3:454d1f4c8fd7 97 unsigned MaxIterations = 4096;
4180_1 3:454d1f4c8fd7 98 for(unsigned y=0; y<ImageHeight; ++y) {
4180_1 3:454d1f4c8fd7 99 double c_im = MaxIm - y*Im_factor;
4180_1 3:454d1f4c8fd7 100 for(unsigned x=0; x<ImageWidth; ++x) {
4180_1 3:454d1f4c8fd7 101 double c_re = MinRe + x*Re_factor;
4180_1 3:454d1f4c8fd7 102 double Z_re = c_re, Z_im = c_im;
4180_1 3:454d1f4c8fd7 103 bool isInside = true;
4180_1 3:454d1f4c8fd7 104 int niterations=0;
4180_1 3:454d1f4c8fd7 105 for(unsigned n=0; n<MaxIterations; ++n) {
4180_1 3:454d1f4c8fd7 106 double Z_re2 = Z_re*Z_re, Z_im2 = Z_im*Z_im;
4180_1 3:454d1f4c8fd7 107 if(Z_re2 + Z_im2 > 4) {
4180_1 3:454d1f4c8fd7 108 niterations = n;
4180_1 3:454d1f4c8fd7 109 isInside = false;
4180_1 3:454d1f4c8fd7 110 break;
4180_1 3:454d1f4c8fd7 111 }
4180_1 3:454d1f4c8fd7 112 Z_im = 2*Z_re*Z_im + c_im;
4180_1 3:454d1f4c8fd7 113 Z_re = Z_re2 - Z_im2 + c_re;
4180_1 3:454d1f4c8fd7 114 }
4180_1 5:a1ef40ff0f78 115 if(isInside==false) uLCD.pixel(x,y,((niterations & 0xF00)<<12)+((niterations & 0xF0)<<8)+((niterations & 0x0F)<<4) );
4180_1 3:454d1f4c8fd7 116 }
4180_1 3:454d1f4c8fd7 117 }
4180_1 5:a1ef40ff0f78 118 wait(5);
4180_1 5:a1ef40ff0f78 119 // PLASMA wave BLIT animation
4180_1 5:a1ef40ff0f78 120 uLCD.cls();
4180_1 5:a1ef40ff0f78 121 int num_cols=40;
4180_1 5:a1ef40ff0f78 122 int num_rows=40;
4180_1 5:a1ef40ff0f78 123 double a,b,c=0.0;
4180_1 5:a1ef40ff0f78 124 while(1) {
4180_1 5:a1ef40ff0f78 125 for (int k=0; k<num_cols; k++) {
4180_1 5:a1ef40ff0f78 126 b= (1+sin(3.14159*k*0.75/(num_cols-1.0)+c))*0.5;
4180_1 5:a1ef40ff0f78 127 for (int i=0; i<num_rows; i++) {
4180_1 5:a1ef40ff0f78 128 a= (1+sin(3.14159*i*0.75/(num_rows-1.0)+c))*0.5;
4180_1 5:a1ef40ff0f78 129 // a and b will be a sine wave output between 0 and 1
4180_1 5:a1ef40ff0f78 130 // sine wave was scaled for nice effect across array
4180_1 5:a1ef40ff0f78 131 // uses a and b to compute pixel colors based on rol and col location in array
4180_1 5:a1ef40ff0f78 132 // also keeps colors at the same brightness level
4180_1 5:a1ef40ff0f78 133 if ((a+b) <.667)
4180_1 5:a1ef40ff0f78 134 pixelcolors[i][k] = (255-(int(240.0*((a+b)/0.667)))<<16) | (int(240.0*((a+b)/0.667))<<8) | 0;
4180_1 5:a1ef40ff0f78 135 else if ((a+b)<1.333)
4180_1 5:a1ef40ff0f78 136 pixelcolors[i][k] = (0 <<16) | (255-(int (240.0*((a+b-0.667)/0.667)))<<8) | int(240.0*((a+b-0.667)/0.667));
4180_1 5:a1ef40ff0f78 137 else
4180_1 5:a1ef40ff0f78 138 pixelcolors[i][k] = (int(255*((a+b-1.333)/0.667))<<16) | (0<<8) | (255-(int (240.0*((a+b-1.333)/0.667))));
4180_1 5:a1ef40ff0f78 139 }
4180_1 5:a1ef40ff0f78 140 }
4180_1 5:a1ef40ff0f78 141 uLCD.BLIT(50, 50, 40, 40, &pixelcolors[0][0]);
4180_1 5:a1ef40ff0f78 142 c = c + 0.0314159*3.0;
4180_1 5:a1ef40ff0f78 143 if (c > 6.2831) c = 0.0;
4180_1 5:a1ef40ff0f78 144 }
4180_1 5:a1ef40ff0f78 145 }