TFT_4DGL_main.cpp

00001 //
00002 // TFT_4DGL is a class to drive 4D Systems TFT touch screens
00003 //
00004 // Copyright (C) <2010> Stephane ROCHON <stephane.rochon at free.fr>
00005 //
00006 // TFT_4DGL is free software: you can redistribute it and/or modify
00007 // it under the terms of the GNU General Public License as published by
00008 // the Free Software Foundation, either version 3 of the License, or
00009 // (at your option) any later version.
00010 //
00011 // TFT_4DGL is distributed in the hope that it will be useful,
00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014 // GNU General Public License for more details.
00015 //
00016 // You should have received a copy of the GNU General Public License
00017 // along with TFT_4DGL.  If not, see <http://www.gnu.org/licenses/>.
00018 
00019 #include "mbed.h"
00020 #include "TFT_4DGL.h"
00021 
00022 #define ARRAY_SIZE(X) sizeof(X)/sizeof(X[0])
00023 
00024 
00025 
00026 //Serial pc(USBTX,USBRX);
00027 
00028 //******************************************************************************************************
00029 TFT_4DGL :: TFT_4DGL(PinName tx, PinName rx, PinName rst) : _cmd(tx, rx), 
00030                                                             _rst(rst) 
00031 #if DEBUGMODE
00032                                                             ,pc(USBTX, USBRX)
00033 #endif // DEBUGMODE
00034 { // Constructor
00035 
00036 #if DEBUGMODE
00037     pc.baud(115200);
00038 
00039     pc.printf("\n\n\n");
00040     pc.printf("********************\n");
00041     pc.printf("TFT_4DGL CONSTRUCTOR\n");
00042     pc.printf("********************\n");
00043 #endif
00044 
00045     _rst = 1;    // put RESET pin to high to start TFT screen
00046     reset();     // will toggle led1
00047     autobaud();  // send autobaud command
00048     version();   // get version information
00049     cls();       // clear screen
00050 
00051     current_col         = 0;            // initial cursor col
00052     current_row         = 0;            // initial cursor row
00053     current_color       = WHITE;        // initial text color
00054     current_orientation = IS_PORTRAIT;  // initial screen orientation
00055 
00056     set_font(FONT_12X34);                 // initial font
00057     text_mode(OPAQUE);                  // initial texr mode
00058 }
00059 
00060 //******************************************************************************************************
00061 void TFT_4DGL :: writeBYTE(char c) { // send a BYTE command to screen
00062 
00063     _cmd.putc(c);
00064     wait_ms(1);
00065 
00066 #if DEBUGMODE
00067     pc.printf("   Char sent : 0x%02X\n",c);
00068 #endif
00069 
00070 }
00071 
00072 //******************************************************************************************************
00073 void TFT_4DGL :: freeBUFFER(void) {       // Clear serial buffer before writing command
00074 
00075     while (_cmd.readable()) _cmd.getc();  // clear buffer garbage
00076 }
00077 
00078 //******************************************************************************************************
00079 int TFT_4DGL :: writeCOMMAND(char *command, int number) { // send several BYTES making a command and return an answer
00080 
00081 #if DEBUGMODE
00082     pc.printf("\n");
00083     pc.printf("New COMMAND : 0x%02X\n", command[0]);
00084 #endif
00085     int i, resp = 0;
00086     freeBUFFER();
00087 
00088     for (i = 0; i < number; i++) writeBYTE(command[i]); // send command to serial port
00089 
00090     while (!_cmd.readable()) wait_ms(TEMPO);              // wait for screen answer
00091     if (_cmd.readable()) resp = _cmd.getc();           // read response if any
00092     switch (resp) {
00093         case ACK :                                     // if OK return   1
00094             resp =  1;
00095             break;
00096         case NAK :                                     // if NOK return -1
00097             resp = -1;
00098             break;
00099         default :
00100             resp =  0;                                 // else return   0
00101             break;
00102     }
00103 #if DEBUGMODE
00104     pc.printf("   Answer received : %d\n",resp);
00105 #endif
00106 
00107     return resp;
00108 }
00109 
00110 //**************************************************************************
00111 void TFT_4DGL :: reset() {  // Reset Screen
00112     //DigitalOut led(LED1);
00113     _rst = 0;               // put RESET pin to low
00114     wait_ms(TEMPO);         // wait a few milliseconds for command reception
00115     wait_ms(TEMPO);
00116     _rst = 1;               // put RESET back to high
00117     //led=1;
00118     wait(3);                // wait 3s for screen to restart
00119     //led=0;
00120     
00121     freeBUFFER();           // clean buffer from possible garbage
00122 }
00123 
00124     
00125 //**************************************************************************
00126 void TFT_4DGL :: autobaud() { // send AutoBaud command (9600)
00127     char command[1] = "";
00128     command[0] = AUTOBAUD;
00129     writeCOMMAND(command, 1);
00130 }
00131 
00132 //**************************************************************************
00133 void TFT_4DGL :: cls() {  // clear screen
00134     char command[1] = "";
00135     command[0] = CLS;
00136     writeCOMMAND(command, 1);
00137 }
00138 
00139 //**************************************************************************
00140 void TFT_4DGL :: version() {  // get API version
00141     char command[2] = "";
00142     command[0] = VERSION;
00143     command[1] = OFF;
00144     readVERSION(command, 2);
00145 }
00146 
00147 //**************************************************************************
00148 void TFT_4DGL :: baudrate(int speed) {  // set screen baud rate
00149     char command[2]= "";
00150     command[0] = BAUDRATE;
00151     switch (speed) {
00152         case  110 :
00153             command[1] = BAUD_110;
00154             break;
00155         case  300 :
00156             command[1] = BAUD_300;
00157             break;
00158         case  600 :
00159             command[1] = BAUD_600;
00160             break;
00161         case 1200 :
00162             command[1] = BAUD_1200;
00163             break;
00164         case 2400 :
00165             command[1] = BAUD_2400;
00166             break;
00167         case 4800 :
00168             command[1] = BAUD_4800;
00169             break;
00170         case 9600 :
00171             command[1] = BAUD_9600;
00172             break;
00173         case 14400 :
00174             command[1] = BAUD_14400;
00175             break;
00176         case 19200 :
00177             command[1] = BAUD_19200;
00178             break;
00179         case 31250 :
00180             command[1] = BAUD_31250;
00181             break;
00182         case 38400 :
00183             command[1] = BAUD_38400;
00184             break;
00185         case 56000 :
00186             command[1] = BAUD_56000;
00187             break;
00188         case 57600 :
00189             command[1] = BAUD_57600;
00190             break;
00191         case 115200 :
00192             command[1] = BAUD_115200;
00193             break;
00194         case 128000 :
00195             command[1] = BAUD_128000;
00196             break;
00197         case 256000 :
00198             command[1] = BAUD_256000;
00199             break;
00200         default   :
00201             command[1] = BAUD_9600;
00202             speed = 9600;
00203             break;
00204     }
00205 
00206     int i, resp = 0;
00207 
00208     freeBUFFER();
00209 
00210     for (i = 0; i <2; i++) writeBYTE(command[i]);      // send command to serial port
00211     _cmd.baud(speed);                                  // set mbed to same speed
00212 
00213     while (!_cmd.readable()) wait_ms(TEMPO);           // wait for screen answer
00214 
00215     if (_cmd.readable()) resp = _cmd.getc();           // read response if any
00216     switch (resp) {
00217         case ACK :                                     // if OK return   1
00218             resp =  1;
00219             break;
00220         case NAK :                                     // if NOK return -1
00221             resp = -1;
00222             break;
00223         default :
00224             resp =  0;                                 // else return   0
00225             break;
00226     }
00227 }
00228 
00229 //******************************************************************************************************
00230 int TFT_4DGL :: readVERSION(char *command, int number) { // read screen info and populate data
00231 
00232     int i, temp = 0, resp = 0;
00233     char response[5] = "";
00234 
00235     freeBUFFER();
00236 
00237     for (i = 0; i < number; i++) writeBYTE(command[i]);    // send all chars to serial port
00238 
00239     while (!_cmd.readable()) wait_ms(TEMPO);               // wait for screen answer
00240 
00241     while (_cmd.readable() && resp < ARRAY_SIZE(response)) {
00242         temp = _cmd.getc();
00243         response[resp++] = (char)temp;
00244     }
00245     switch (resp) {
00246         case 5 :                                           // if OK populate data and return 1
00247             type      = response[0];
00248             revision  = response[1];
00249             firmware  = response[2];
00250             reserved1 = response[3];
00251             reserved2 = response[4];
00252             resp      = 1;
00253             break;
00254         default :
00255             resp =  0;                                     // else return 0
00256             break;
00257     }
00258     return resp;
00259 }
00260 
00261 //****************************************************************************************************
00262 void TFT_4DGL :: background_color(int color) {            // set screen background color
00263     char command[3]= "";                                  // input color is in 24bits like 0xRRGGBB
00264 
00265     command[0] = BCKGDCOLOR;
00266 
00267     int red5   = (color >> (16 + 3)) & 0x1F;              // get red on 5 bits
00268     int green6 = (color >> (8 + 2))  & 0x3F;              // get green on 6 bits
00269     int blue5  = (color >> (0 + 3))  & 0x1F;              // get blue on 5 bits
00270 
00271     command[1] = ((red5 << 3)   + (green6 >> 3)) & 0xFF;  // first part of 16 bits color
00272     command[2] = ((green6 << 5) + (blue5 >>  0)) & 0xFF;  // second part of 16 bits color
00273 
00274     writeCOMMAND(command, 3);
00275 }
00276 
00277 //****************************************************************************************************
00278 void TFT_4DGL :: display_control(char mode, char value) {   // set screen mode to value
00279     char command[3]= "";
00280 
00281     command[0] = DISPCONTROL;
00282     command[1] = mode;
00283     command[2] = value;
00284 
00285     if (mode ==  ORIENTATION) {
00286         switch (value) {
00287             case LANDSCAPE :
00288                 current_orientation = IS_LANDSCAPE;
00289                 break;
00290             case LANDSCAPE_R :
00291                 current_orientation = IS_LANDSCAPE;
00292                 break;
00293             case PORTRAIT :
00294                 current_orientation = IS_PORTRAIT;
00295                 break;
00296             case PORTRAIT_R :
00297                 current_orientation = IS_PORTRAIT;
00298                 break;
00299         }
00300     }
00301     writeCOMMAND(command, 3);
00302     set_font(current_font);
00303 }
00304 
00305 //****************************************************************************************************
00306 void TFT_4DGL :: set_volume(char value) {   // set sound volume to value
00307     char command[2]= "";
00308 
00309     command[0] = SETVOLUME;
00310     command[1] = value;
00311 
00312     writeCOMMAND(command, 2);
00313 }
00314 
00315 
00316 //******************************************************************************************************
00317 void TFT_4DGL :: getTOUCH(char *command, int number, int *x, int *y) { // read screen info and populate data
00318 
00319 #if DEBUGMODE
00320     pc.printf("\n");
00321     pc.printf("New COMMAND : 0x%02X\n", command[0]);
00322 #endif
00323     int i, temp = 0, resp = 0;
00324     char response[5] = "";
00325 
00326     freeBUFFER();
00327 
00328     for (i = 0; i < number; i++) writeBYTE(command[i]);    // send all chars to serial port
00329 
00330     while (!_cmd.readable()) wait_ms(TEMPO);               // wait for screen answer
00331 
00332     while (_cmd.readable() && resp < ARRAY_SIZE(response)) {
00333         temp = _cmd.getc();
00334         response[resp++] = (char)temp;
00335     }
00336 
00337 #if DEBUGMODE
00338     pc.printf("   Answer received %d : 0x%02X 0x%02X 0x%02X 0x%02X\n", resp, response[0], response[1], response[2], response[3]);
00339 #endif
00340 
00341     switch (resp) {
00342         case 4 :                                                              // if OK populate data
00343             *x = ((response[0]<<8)+ response[1]) * (response[0] != 0xFF);
00344             *y = ((response[2]<<8)+ response[3]) * (response[2] != 0xFF);
00345             break;
00346         default :
00347             *x = -1;
00348             *y = -1;
00349             break;
00350     }
00351 
00352 #if DEBUGMODE
00353     pc.printf("   X,Y : %03d,%03d\n", *x, *y);
00354 #endif
00355 }
00356 
00357 //******************************************************************************************************
00358 int TFT_4DGL :: getSTATUS(char *command, int number) { // read screen info and populate data
00359 
00360 #if DEBUGMODE
00361     pc.printf("\n");
00362     pc.printf("New COMMAND : 0x%02X\n", command[0]);
00363 #endif
00364 
00365     int i, temp = 0, resp = 0;
00366     char response[5] = "";
00367 
00368     freeBUFFER();
00369 
00370     for (i = 0; i < number; i++) writeBYTE(command[i]);    // send all chars to serial port
00371 
00372     while (!_cmd.readable()) wait_ms(TEMPO);    // wait for screen answer
00373 
00374     while (_cmd.readable() && resp < ARRAY_SIZE(response)) {
00375         temp = _cmd.getc();
00376         response[resp++] = (char)temp;
00377     }
00378     switch (resp) {
00379         case 4 :
00380             resp = (int)response[1];         // if OK populate data
00381             break;
00382         default :
00383             resp =  -1;                      // else return   0
00384             break;
00385     }
00386     
00387 #if DEBUGMODE
00388     pc.printf("   Answer received : %d\n", resp);
00389 #endif
00390 
00391     return resp;
00392 }