Getting Started with the Arduino TFT Screen

Copy
1#include <TFT.h> // Hardware-specific library
2#include <SPI.h>
3
4#define CS   10
5#define DC   9
6#define RESET  8
7
8// pin definition for the Leonardo
9// #define CS   7
10// #define DC   0
11// #define RESET  1
12
13TFT myScreen = TFT(CS, DC, RESET);

Copy
1void setup(){
2
3  myScreen.begin();
4
5  myScreen.background(0,0,0);  // clear the screen with black
6
7  delay(1000);  // pause for dramatic effect
8}

Copy
1void loop(){
2
3  myScreen.stroke(255, 0, 0); // set the stroke color to red
4
5  myScreen.line(0, 10, myScreen.width(), 10); // draw a line across the screen
6
7  delay(1000);
8
9  myScreen.noStroke(); // don't draw a line around the next rectangle
10
11  myScreen.fill(0,255,0); // set the fill color to green
12
13  myScreen.rect(0,20,myScreen.width(),10); //draw a rectangle across the screen
14
15  delay(1000);
16
17  myScreen.fill(0,0,255); // set the fill color to blue
18
19  myScreen.stroke(255,255,255); // outline the rectangle with a white line
20
21  myScreen.rect(0,45,myScreen.width(),45); // draw a fat rectangle
22
23  delay(1000);
24
25  myScreen.background(0,0,0); // clear the screen before starting again
26
27  delay(1000);
28}

Copy
1#include <TFT.h> // Hardware-specific library
2#include <SPI.h>
3#include <Esplora.h>
4
5void setup(){
6
7  EsploraTFT.begin();
8
9  EsploraTFT.background(0,0,0);  // clear the screen with black
10
11  delay(1000);  // pause for dramatic effect
12}
13
14void loop(){
15
16  EsploraTFT.stroke(255, 0, 0); // set the stroke color to red
17
18  EsploraTFT.line(0, 10, EsploraLCD.width(), 10); // draw a line across the screen
19
20  delay(1000);
21
22  EsploraTFT.noStroke(); // don't draw a line around the next rectangle
23
24  EsploraTFT.fill(0,255,0); // set the fill color to green
25
26  EsploraTFT.rect(0,20,EsploraTFT.width(),20); //draw a rectangle across the screen
27
28  delay(1000);
29
30  EsploraTFT.fill(0,0,255); // set the fill color to blue
31
32  EsploraTFT.stroke(255,255,255); // outline the rectangle with a white line
33
34  EsploraTFT.rect(0,45,EsploraTFT.width(),50); // draw a fat rectangle
35
36  delay(1000);
37
38  EsploraTFT.background(0,0,0); // clear the screen before starting again
39
40  delay(1000);
41}

Copy
1#include <TFT.h> // Hardware-specific library
2#include <SPI.h>
3
4#define CS   10
5#define DC   9
6#define RESET  8
7
8// pin definition for the Leonardo
9// #define CS   7
10// #define DC   0
11// #define RESET  1
12
13TFT myScreen = TFT(CS, DC, RESET);
14
15// initial position of the point is the middle of the screen
16// initial position of the point is the middle of the screen
17int xPos = 80;
18int yPos = 64;
19
20// direction and speed
21int xDir = 1;
22int yDir = 1;
23
24// variables to keep track of the point's location
25int xPrev = xPos;
26int yPrev = yPos;
27
28void setup(){
29
30  myScreen.begin();
31
32  myScreen.background(0,0,0); // clear the screen
33}

Copy
1void loop(){
2
3  // update the location of the dot
4
5  xPos = xPos + xDir;
6
7  yPos = yPos + yDir;
8
9  // check if the current location is different than the previous
10
11  if(xPos != xPrev || yPos != yPrev){
12
13    myScreen.stroke(0,0,0); // set the stroke color to black
14
15    myScreen.point(xPrev, yPrev); // color in the previous point
16
17  }
18
19  // draw a point in the current location
20
21  myScreen.stroke(255,255,255);
22
23  myScreen.point(xPos, yPos);
24
25  // if the x or x position is at the screen edges, reverse direction
26
27  if(xPos >= 160 || xPos <= 0){
28
29    xDir = xDir*-1;
30
31  }
32
33  if(yPos >= 128 || yPos <= 0){
34
35    yDir = yDir*-1;
36
37  }
38
39  // update the point's previous location
40
41  xPrev=xPos;
42
43  yPrev=yPos;
44
45  // a 33ms delay means the screen updates 30 times a second
46
47  delay(33);
48
49}

Copy
1#include <TFT.h> // Hardware-specific library
2#include <SPI.h>
3#include <Esplora.h>
4
5// initial position of the point is the middle of the screen
6int xPos = 80;
7int yPos = 64;
8
9// direction and speed
10int xDir = 1;
11int yDir = 1;
12
13// variables to keep track of the point's location
14int xPrev, yPrev;
15
16void setup(){
17
18  EsploraTFT.begin();
19
20  EsploraTFT.background(0,0,0);
21}
22
23void loop(){
24
25  // update the location of the dot
26
27  xPos = xPos + xDir;
28
29  yPos = yPos + yDir;
30
31  // check if the current location is different than the previous
32
33  if(xPos != xPrev || yPos != yPrev){
34
35    EsploraTFT.stroke(0,0,0); // set the stroke color to black
36
37    EsploraTFT.point(xPrev, yPrev); // color in the previous point
38
39  }
40
41  // draw a point in the current location
42
43  EsploraTFT.stroke(255,255,255);
44
45  EsploraTFT.point(xPos, yPos);
46
47  // if the x or x position is at the screen edges, reverse direction
48
49  if(xPos >= 160 || xPos <= 0){
50
51    xDir = xDir*-1;
52
53  }
54
55  if(yPos >= 128 || yPos <= 0){
56
57    yDir = yDir*-1;
58
59  }
60
61  // update the point's previous location
62
63  xPrev=xPos;
64
65  yPrev=yPos;
66
67  // slight pause
68
69  delay(33);
70
71}

Copy
1#include <TFT.h> // Hardware-specific library
2#include <SPI.h>
3
4#define CS   10
5#define DC   9
6#define RESET  8
7
8// pin definition for the Leonardo
9// #define CS   7
10// #define DC   0
11// #define RESET  1
12
13TFT myScreen = TFT(CS, DC, RESET);
14
15// variable to keep track of the elapsed time
16int counter = 0;
17// char array to print time
18char printout[4];
19
20void setup(){
21
22  myScreen.begin();
23
24  myScreen.background(0,0,0); // clear the screen
25
26  myScreen.stroke(255,0,255);
27
28  // static text
29
30  myScreen.text("Running for",0,0);
31
32  myScreen.text("seconds",0,30);
33
34  // increase font size for text in loop()
35
36  myScreen.setTextSize(3);
37}

Copy
1void loop(){
2
3    // get elapsed time
4
5    counter = millis();
6
7    // convert to a string
8
9    String elapsedTime = String(counter/1000);
10
11    // add to an array
12
13    elapsedTime.toCharArray(printout,4);
14
15    // print out and erase
16
17    myScreen.stroke(255,255,255);
18
19    myScreen.text(printout,0,10);
20
21    delay(1000);
22
23    myScreen.stroke(0,0,0);
24
25    myScreen.text(printout,0,10);
26}

Copy
1#include <TFT.h> // Hardware-specific library
2#include <SPI.h>
3#include <Esplora.h>
4
5// variable to keep track of the elapsed time
6long counter = 0;
7// char array to print time
8char printout[4];
9
10void setup(){
11
12  EsploraTFT.begin();
13
14  EsploraTFT.background(0,0,0); // clear the screen
15
16  EsploraTFT.stroke(255,0,255);
17
18  // static text
19
20  EsploraTFT.text("Running for",0,0);
21
22  EsploraTFT.text("seconds",0,30);
23
24  // increase font size for text in loop()
25
26  EsploraTFT.setTextSize(3);
27}
28
29void loop(){
30
31    // get elapsed time
32
33    counter = millis();
34
35    // convert to a string
36
37    String elapsedTime = String(counter/1000);
38
39    // add to an array
40
41    elapsedTime.toCharArray(printout,4);
42
43    // print out and erase
44
45    EsploraTFT.stroke(255,255,255);
46
47    EsploraTFT.text(printout,0,10);
48
49    delay(1000);
50
51    EsploraTFT.stroke(0,0,0);
52
53    EsploraTFT.text(printout,0,10);
54}

Copy
1// include the necessary libraries
2#include <SPI.h>
3#include <SD.h>
4#include <TFT.h> // Hardware-specific library
5
6// pin definition for the Uno
7#define SD_CS  11
8#define LCD_CS 10
9#define DC    9
10#define RESET    8
11
12// pin definition for the Leonardo
13// #define SD_CS  8
14// #define LCD_CS 7
15// #define DC   0
16// #define RESET  1
17
18TFT myScreen = TFT(LCD_CS, DC, RESET);
19
20// this variable represents the image to be drawn on screen
21
22PImage image;
23
24void setup() {
25
26  // initialize the serial port
27
28  Serial.begin(9600);
29
30  while (!Serial) {
31
32    // wait for serial line to be ready
33
34    // needed for the Leonardo
35
36  }
37
38  // try to access the SD card
39
40  Serial.print("Initializing SD card...");
41
42  if (!SD.begin(SD_CS)) {
43
44    Serial.println("failed!");
45
46    return;
47
48  }
49
50  Serial.println("OK!");
51
52  // initialize and clear the GLCD screen
53
54  myScreen.begin();
55
56  myScreen.background(255, 255, 255);
57
58  // load the image from the SD card
59
60  image = myScreen.loadImage("arduino.bmp");
61
62  // check if the image loaded properly
63
64  if (image.isValid() != true) {
65
66    Serial.println("error while loading arduino.bmp");
67
68  }
69
70  //write the image on screen
71
72  myScreen.image(image, 0, 0);
73}
74
75void loop(){
76// nothing happening here
77}

Copy
1// include the necessary libraries
2#include <SPI.h>
3#include <SD.h>
4#include <TFT.h> // Hardware-specific library
5#include <Esplora.h>
6
7// SD Chip Select pin
8#define SD_CS    8
9
10// this variable represents the image to be drawn on screen
11
12PImage image;
13
14void setup() {
15
16  // initialize the serial port
17
18  Serial.begin(9600);
19
20  while (!Serial) {
21
22    // wait for serial line to be ready
23
24  }
25
26  // try to access the SD card
27
28  Serial.print("Initializing SD card...");
29
30  if (!SD.begin(SD_CS)) {
31
32    Serial.println("failed!");
33
34    return;
35
36  }
37
38  Serial.println("OK!");
39
40  // initialize and clear the GLCD screen
41
42  EsploraTFT.begin();
43
44  EsploraTFT.background(255, 255, 255);
45
46  // load the image from the SD card
47
48  image = EsploraTFT.loadImage("arduino.bmp");
49
50  // check if the image loaded properly
51
52  if (image.isValid() != true) {
53
54    Serial.println("error while loading arduino.bmp");
55
56  }
57
58  //write the image on screen
59
60  EsploraTFT.image(image, 0, 0);
61}
62
63void loop(){
64// nothing happening here
65}