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