/*
   This sketch has been written to test the Processing screenshot client.
 
   It has been created to work with the TFT_eSPI library here:
   https://github.com/Bodmer/TFT_eSPI
 
   It sends screenshots to a PC running a Processing client sketch.
 
   The Processing IDE that will run the client sketch can be downloaded
   here:  https://processing.org/
 
   The Processing sketch needed is contained within a tab attached to this
   Arduino sketch. Cut and paste that tab into the Processing IDE and run.
   Read the Processing sketch header for instructions.
 
   This sketch uses the GLCD, 2, 4, 6 fonts only.
 
   Make sure all the display driver and pin connections are correct by
   editing the User_Setup.h file in the TFT_eSPI library folder.
 
   Maximum recommended SPI clock rate is 27MHz when reading pixels, 40MHz
   seems to be OK with ILI9341 displays but this is above the manufacturers
   specified maximum clock rate.
 
   In the setup file you can define different write and read SPI clock rates
   
   In the setup file you can define TFT_SDA_READ for a TFT with bi-directional
   SDA pin (otherwise the normal MISO pin will be used to read from the TFT)
 
   >>>>   NOTE: NOT ALL TFTs SUPPORT READING THE CGRAM (pixel) MEMORY   <<<<
 
   #########################################################################
   ###### DON'T FORGET TO UPDATE THE User_Setup.h FILE IN THE LIBRARY ######
   #########################################################################
 */
 
 // Created by: Bodmer  5/3/17
 // Updated by: Bodmer 10/3/17
 // Updated by: Bodmer 23/11/18 to support SDA reads and the ESP32
 // Version: 0.07
 
 // MIT licence applies, all text above must be included in derivative works
 
 #include <TFT_eSPI.h> // Hardware-specific library
 #include <SPI.h>
 
 TFT_eSPI tft = TFT_eSPI(); // Invoke custom library
 
 unsigned long targetTime = 0;
 byte red = 0x1F;
 byte green = 0;
 byte blue = 0;
 byte state = 0;
 unsigned int colour = red << 11; // Colour order is RGB 5+6+5 bits each
 
 void setup(void) {
   Serial.begin(921600); // Set to a high rate for fast image transfer to a PC
 
   tft.init();
   tft.setRotation(0);
   tft.fillScreen(TFT_BLACK);
 
   randomSeed(analogRead(A0));
 
   targetTime = millis() + 1000;
 }
 
 #define RGB_TEST false // true produces a simple RGB color test screen
 
 void loop() {
 
   if (targetTime < millis()) {
     if (!RGB_TEST)
     {
       targetTime = millis() + 1500; // Wait a minimum of 1.5s
 
       tft.setRotation(random(4));
       rainbow_fill(); // Fill the screen with rainbow colours
 
       tft.setTextColor(TFT_BLACK); // Text background is not defined so it is transparent
       tft.setTextDatum(TC_DATUM);  // Top Centre datum
       int xpos = tft.width() / 2;  // Centre of screen
 
       tft.setTextFont(0);        // Select font 0 which is the Adafruit font
       tft.drawString("Original Adafruit font!", xpos, 5);
 
       // The new larger fonts do not need to use the .setCursor call, coords are embedded
       tft.setTextColor(TFT_BLACK); // Do not plot the background colour
 
       // Overlay the black text on top of the rainbow plot (the advantage of not drawing the background colour!)
       tft.drawString("Font size 2", xpos, 14, 2); // Draw text centre at position xpos, 14 using font 2
       tft.drawString("Font size 4", xpos, 30, 4); // Draw text centre at position xpos, 30 using font 4
       tft.drawString("12.34", xpos, 54, 6);       // Draw text centre at position xpos, 54 using font 6
 
       tft.drawString("12.34 is in font size 6", xpos, 92, 2); // Draw text centre at position xpos, 92 using font 2
       // Note the x position is the top of the font!
 
       // draw a floating point number
       float pi = 3.1415926; // Value to print
       int precision = 3;    // Number of digits after decimal point
 
       int ypos = 110;     // y position
 
       tft.setTextDatum(TR_DATUM); // Top Right datum so text butts neatly to xpos (right justified)
 
       tft.drawFloat(pi, precision, xpos, ypos, 2); // Draw rounded number and return new xpos delta for next print position
 
       tft.setTextDatum(TL_DATUM);  // Top Left datum so text butts neatly to xpos (left justified)
 
       tft.drawString(" is pi", xpos, ypos, 2);
 
       tft.setTextSize(1);           // We are using a font size multiplier of 1
       tft.setTextDatum(TC_DATUM);   // Top Centre datum
       tft.setTextColor(TFT_BLACK);  // Set text colour to black, no background (so transparent)
 
       tft.drawString("Transparent...", xpos, 125, 4);  // Font 4
 
       tft.setTextColor(TFT_WHITE, TFT_BLACK);          // Set text colour to white and background to black
       tft.drawString("White on black", xpos, 150, 4);  // Font 4
 
       tft.setTextColor(TFT_GREEN, TFT_BLACK); // This time we will use green text on a black background
 
       tft.setTextFont(2); // Select font 2, now we do not need to specify the font in drawString()
 
       // An easier way to position text and blank old text is to set the datum and use width padding
       tft.setTextDatum(BC_DATUM);          // Bottom centre for text datum
       tft.setTextPadding(tft.width() + 1); // Pad text to full screen width + 1 spare for +/-1 position rounding
 
       tft.drawString("Ode to a Small Lump of Green Putty", xpos, 230 - 32);
       tft.drawString("I Found in My Armpit One Midsummer", xpos, 230 - 16);
       tft.drawString("Morning", xpos, 230);
 
       tft.setTextDatum(TL_DATUM); // Reset to top left for text datum
       tft.setTextPadding(0);      // Reset text padding to 0 pixels
 
       // Now call the screen server to send a copy of the TFT screen to the PC running the Processing client sketch
       screenServer();
     }
     else
     {
       tft.fillScreen(TFT_BLACK);
       tft.fillRect( 0, 0, 16, 16, TFT_RED);
       tft.fillRect(16, 0, 16, 16, TFT_GREEN);
       tft.fillRect(32, 0, 16, 16, TFT_BLUE);
       screenServer();
     }
   }
 }
 
 // Fill screen with a rainbow pattern
 void rainbow_fill()
 {
   // The colours and state are not initialised so the start colour changes each time the function is called
   int rotation = tft.getRotation();
   tft.setRotation(random(4));
   for (int i = tft.height() - 1; i >= 0; i--) {
     // This is a "state machine" that ramps up/down the colour brightnesses in sequence
     switch (state) {
       case 0:
         green ++;
         if (green == 64) {
           green = 63;
           state = 1;
         }
         break;
       case 1:
         red--;
         if (red == 255) {
           red = 0;
           state = 2;
         }
         break;
       case 2:
         blue ++;
         if (blue == 32) {
           blue = 31;
           state = 3;
         }
         break;
       case 3:
         green --;
         if (green == 255) {
           green = 0;
           state = 4;
         }
         break;
       case 4:
         red ++;
         if (red == 32) {
           red = 31;
           state = 5;
         }
         break;
       case 5:
         blue --;
         if (blue == 255) {
           blue = 0;
           state = 0;
         }
         break;
     }
     colour = red << 11 | green << 5 | blue;
     // Draw a line 1 pixel wide in the selected colour
     tft.drawFastHLine(0, i, tft.width(), colour); // tft.width() returns the pixel width of the display
   }
   tft.setRotation(rotation);
 }

© 2023 acidvegas, inc • generated with stagit