Merge branch 'master' of https://github.com/sparkfun/HyperDisplay_KWH018ST01_4WSPI_ArduinoLibrary

Author: oclyke

README.md

@@ -26,7 +26,7 @@ Documentation
 
 Products that use this Library 
 ---------------------------------
-* [SparkFun 1.8 inch TFT Breakout 128x160 (coming soon!)](https://www.sparkfun.com/products/15143)
+* [SparkFun 1.8 inch TFT Breakout 128x160](https://www.sparkfun.com/products/15143)
 
 Version History
 ---------------

examples/Example1_DisplayTest/Example1_DisplayTest.ino

@@ -39,14 +39,18 @@ ILI9163C_color_18_t defaultColor; // Global objects are used for default colors
 
 void setup() {
   SERIAL_PORT.begin(9600);
+
+  //Uncomment this if you want to wait to println until the serial monitor is open.
+  //while (!SERIAL_PORT); //Wait for Serial Monitor to Open
+
   SERIAL_PORT.println("Example1 Display Test : SparkFun TFT LCD 1.8in Breakout");
 
   myTFT.begin(DC_PIN, CS_PIN, PWM_PIN, SPI_PORT, SPI_SPEED);
   myTFT.clearDisplay();
 
   myTFT.setTextCursor(0,0);            // Sets the cursor relative to the current window, however the current (default) window is equivalent to the whole display. (0,0) is the upper left corner and (myTFT.xExt-1, myTFT.yExt-1) is the lower right
   myTFT.setCurrentWindowColorSequence((color_t)&defaultColor);
-  
+
   uint16_t hue = HSV_HUE_MIN;
   while(hue <= HSV_HUE_MAX){
     myTFT.setTextCursor(0,0);
@@ -58,10 +62,10 @@ void setup() {
 void loop() {
     lineTest();
     delay(500);
-  
+
     rectTest();
     delay(500);
-  
+
     circleTest();
     for(uint8_t indi = 250; indi > 1; indi--){
       myTFT.setBacklight(indi); // Set the brightness of the backlight using PWM output
@@ -77,15 +81,15 @@ void loop() {
 void lineTest( void )
 {
   ILI9163C_color_18_t color;
-  
+
   myTFT.clearDisplay();
 
   color = myTFT.rgbTo18b( 255, 255, 255 );
   for(hd_hw_extent_t indi = 0; indi < myTFT.xExt; indi++)
   {
     myTFT.line(0,0,indi,myTFT.yExt-1,1,(color_t)&color);
   }
-  
+
   color = myTFT.rgbTo18b( 255, 0, 0 );
   for(hd_hw_extent_t indi = 0; indi < myTFT.yExt; indi++)
   {
@@ -139,7 +143,7 @@ void circleTest( void )
 {
   myTFT.clearDisplay();
   ILI9163C_color_18_t color;
-  
+
   for(uint8_t indi = 0; indi < (myTFT.xExt/2 - 1); indi++)
   {
     color = myTFT.hsvTo18b( (uint16_t)((double)(((double)HSV_HUE_MAX*indi)/((double)myTFT.xExt/2 - 1))), 255, 255 );

examples/Example2_HyperDisplayBasics/Example2_HyperDisplayBasics.ino

@@ -27,10 +27,10 @@ This software is open source. Use it how you like, just don't hurt people.
 What is hyperdisplay?
 HD is an abstract C++ library for controlling 2D output devices by taking advantage of a common interface.
 
-Despite many individual display technologies needing varying electrical interfaces to operate they nearly 
-all can be controlled (conceptually) as long as you have the ability to set a particular pixel to an 
+Despite many individual display technologies needing varying electrical interfaces to operate they nearly
+all can be controlled (conceptually) as long as you have the ability to set a particular pixel to an
 arbitrary color. Hyperdisplay "assumes" that this capability exists and then uses it to implement drawing
-functions, text, and many other capabilities in a standard, hardware-independent manner. 
+functions, text, and many other capabilities in a standard, hardware-independent manner.
 */
 
 #define SERIAL_PORT Serial    // Allows users to easily change target serial port (e.g. SAMD21's SerialUSB)
@@ -42,14 +42,18 @@ functions, text, and many other capabilities in a standard, hardware-independent
 #define SPI_SPEED 32000000    // Requests host uC to use the fastest possible SPI speed up to 32 MHz
 
 KWH018ST01_4WSPI myTFT;       // The KWH018ST01_4WSPI class is used for this breakout, and we will call our object myTFT
-                              // The class is derived from the hyperdisplay class, and so it has all the functionality of 
+                              // The class is derived from the hyperdisplay class, and so it has all the functionality of
                               // hyperdisplay plus a little more. In this example we will only focus on the functions that
                               // come from hyperdisplay
 
 ILI9163C_color_18_t defaultColor; // To use a default color it is best to make the variable global
 
 void setup() {
   SERIAL_PORT.begin(9600);
+
+  //Uncomment this if you want to wait to println until the serial monitor is open.
+  //while (!SERIAL_PORT); //Wait for Serial Monitor to Open
+
   SERIAL_PORT.println("Example2 HyperDisplay Basics : SparkFun TFT LCD 1.8in Breakout");
 
   myTFT.begin(DC_PIN, CS_PIN, PWM_PIN, SPI_PORT, SPI_SPEED);  // This is a non-hyperdisplay function, but it is required to make the display work
@@ -61,7 +65,7 @@ void setup() {
   // Exploration of HyperDisplay abilities:
   /*
       The base layer of hyperdisplay only handles drawing functions:
-        pixel   
+        pixel
         xline
         yline
         line
@@ -72,10 +76,10 @@ void setup() {
         fillWindow
       Each of these functions roughly follows a pattern for the arguments: (locations, options, color info)
       Also the location information of these functions is relative to a "window" - though the defualt window
-      the entire display, so for basic applications there's no need to worry about it. 
+      the entire display, so for basic applications there's no need to worry about it.
 
       Because HD can handle everything from monochrome OLEDs to full color TFTs it is up to the user to specify
-      color information. HD uses the notion of color cycles - that is patterns of colors that can be repeated. 
+      color information. HD uses the notion of color cycles - that is patterns of colors that can be repeated.
       Every drawing function uses parameters called colorCycleLength and colorCycleOffset, which default to 1 and 0
   */
 
@@ -97,13 +101,13 @@ void setup() {
   pixelColor.r = 0xFF;            // Set the r, g, and b values how you like
   pixelColor.g = 0;
   pixelColor.b = 0;
-  
-  myTFT.clearDisplay();                     // To be flexible the 'pixel' function needs to take a 'color_t' type 
+
+  myTFT.clearDisplay();                     // To be flexible the 'pixel' function needs to take a 'color_t' type
   myTFT.pixel(0,0, (color_t)&pixelColor);   // so we cast the reference of our pixelColor to the color_t type
   delay(5000);
 
   // Now let's do examples of the other HyperDipslay drawing functions using our color:
-  myTFT.clearDisplay(); 
+  myTFT.clearDisplay();
   myTFT.setTextCursor(0,0);
   myTFT.print("(X/Y)Line Example...");
   delay(1000);
@@ -119,7 +123,7 @@ void setup() {
     0x80, // blue
   };
 
-  myTFT.clearDisplay(); 
+  myTFT.clearDisplay();
   myTFT.setTextCursor(0,0);
   myTFT.print("Rectangle Example...");
   delay(1000);
@@ -129,7 +133,7 @@ void setup() {
   delay(5000);
 
 
-  myTFT.clearDisplay(); 
+  myTFT.clearDisplay();
   myTFT.setTextCursor(0,0);
   myTFT.print("Circle Example...");
   delay(1000);
@@ -138,11 +142,11 @@ void setup() {
   myTFT.circle(64, 64, 24, true, (color_t)&innerRectColor);
   myTFT.circle(64, 64, 12, false, (color_t)&pixelColor);
   delay(5000);
-  
 
 
-  // Now let's talk about the option to use a default color!  
-  myTFT.clearDisplay(); 
+
+  // Now let's talk about the option to use a default color!
+  myTFT.clearDisplay();
   myTFT.setTextCursor(0,0);
   myTFT.print("Default Color Example...");  // Default color is used to print to the screen
   delay(1000);
@@ -151,8 +155,8 @@ void setup() {
   myTFT.pixel(5, 40);                                                   // Default color also can be used in place of a color in any drawing function
   myTFT.setTextCursor(0,0);
   myTFT.setCurrentWindowColorSequence((color_t)&innerRectColor);        // You can change the current default color like this
-  myTFT.print("Changing the default color changes the color of text and drawing functions!");   
-  myTFT.pixel(7, 40);                                                   // And as shown here the new default color is used for the next call to a drawing function                                   
+  myTFT.print("Changing the default color changes the color of text and drawing functions!");
+  myTFT.pixel(7, 40);                                                   // And as shown here the new default color is used for the next call to a drawing function
   delay(20000);
 
 

examples/Example3_AdvancedHyperDisplay/Example3_AdvancedHyperDisplay.ino

@@ -31,12 +31,16 @@ This software is open source. Use it how you like, just don't hurt people.
 #define SPI_PORT SPI
 #define SPI_SPEED 32000000    // Requests host uC to use the fastest possible SPI speed up to 32 MHz
 
-KWH018ST01_4WSPI myTFT;       
+KWH018ST01_4WSPI myTFT;
 
 ILI9163C_color_18_t defaultColor;
 
 void setup() {
   SERIAL_PORT.begin(9600);
+
+  //Uncomment this if you want to wait to println until the serial monitor is open.
+  //while (!SERIAL_PORT); //Wait for Serial Monitor to Open
+
   SERIAL_PORT.println("Example3 Advanced HyperDisplay : SparkFun TFT LCD 1.8in Breakout");
 
   myTFT.begin(DC_PIN, CS_PIN, PWM_PIN, SPI_PORT, SPI_SPEED);  // This is a non-hyperdisplay function, but it is required to make the display work
@@ -49,22 +53,22 @@ void setup() {
   // Here are the function prototypes from the library -- we can break them down bit by bit
   /*
         void     pixel(hd_extent_t x0, hd_extent_t y0, color_t data = NULL, hd_colors_t colorCycleLength = 1, hd_colors_t startColorOffset = 0);
-        void    xline(hd_extent_t x0, hd_extent_t y0, hd_extent_t len, color_t data = NULL, hd_colors_t colorCycleLength = 1, hd_colors_t startColorOffset = 0, bool goLeft = false); 
+        void    xline(hd_extent_t x0, hd_extent_t y0, hd_extent_t len, color_t data = NULL, hd_colors_t colorCycleLength = 1, hd_colors_t startColorOffset = 0, bool goLeft = false);
         void    yline(hd_extent_t x0, hd_extent_t y0, hd_extent_t len, color_t data = NULL, hd_colors_t colorCycleLength = 1, hd_colors_t startColorOffset = 0, bool goUp = false);
-        void    rectangle(hd_extent_t x0, hd_extent_t y0, hd_extent_t x1, hd_extent_t y1, bool filled = false, color_t data = NULL, hd_colors_t colorCycleLength = 1, hd_colors_t startColorOffset = 0, bool reverseGradient = false, bool gradientVertical = false); 
-        void    fillFromArray(hd_extent_t x0, hd_extent_t y0, hd_extent_t x1, hd_extent_t y1, color_t data = NULL, hd_pixels_t numPixels = 0, bool Vh = false); 
+        void    rectangle(hd_extent_t x0, hd_extent_t y0, hd_extent_t x1, hd_extent_t y1, bool filled = false, color_t data = NULL, hd_colors_t colorCycleLength = 1, hd_colors_t startColorOffset = 0, bool reverseGradient = false, bool gradientVertical = false);
+        void    fillFromArray(hd_extent_t x0, hd_extent_t y0, hd_extent_t x1, hd_extent_t y1, color_t data = NULL, hd_pixels_t numPixels = 0, bool Vh = false);
         void    fillWindow(color_t color, hd_colors_t colorCycleLength = 1, hd_colors_t startColorOffset = 0);
-        void    line(hd_extent_t x0, hd_extent_t y0, hd_extent_t x1, hd_extent_t y1, uint16_t width = 1, color_t data = NULL, hd_colors_t colorCycleLength = 1, hd_colors_t startColorOffset = 0, bool reverseGradient = false); 
+        void    line(hd_extent_t x0, hd_extent_t y0, hd_extent_t x1, hd_extent_t y1, uint16_t width = 1, color_t data = NULL, hd_colors_t colorCycleLength = 1, hd_colors_t startColorOffset = 0, bool reverseGradient = false);
         void    polygon(hd_extent_t x[], hd_extent_t y[], uint8_t numSides, uint16_t width = 1, color_t data = NULL, hd_colors_t colorCycleLength = 1, hd_colors_t startColorOffset = 0, bool reverseGradient = false);
-        void    circle(hd_extent_t x0, hd_extent_t y0, hd_extent_t radius, bool filled = false, color_t data = NULL, hd_colors_t colorCycleLength = 1, hd_colors_t startColorOffset = 0, bool reverseGradient = false); 
+        void    circle(hd_extent_t x0, hd_extent_t y0, hd_extent_t radius, bool filled = false, color_t data = NULL, hd_colors_t colorCycleLength = 1, hd_colors_t startColorOffset = 0, bool reverseGradient = false);
   */
   // In every case the first arguments have to do with the geometry of the function and they are required
   // After that come arguments having to do with the color - or more appropriately the color cycle
-  //    - color_t data : this is a pointer to the color. The data that exists at this pointer will be assumed to be of the color type 
+  //    - color_t data : this is a pointer to the color. The data that exists at this pointer will be assumed to be of the color type
   //      that the display uses. This defaults to NULL in which case it will try to use a default color
   //    - hd_colors_t colorCycleLength : this number tells how long the color cycle is - in other words it is a promise that this many
   //      color objects exist consecutively after the pointer 'data.' If not specified this defaults to 1
-  //    - hd_colors_t startColorOffset : this number allows the color cycle to start part-way through the color cycle. If this number is greater 
+  //    - hd_colors_t startColorOffset : this number allows the color cycle to start part-way through the color cycle. If this number is greater
   //      than the color cycle length it is wrapped back around with a modulo operation. This value defaults to 0
   // Then finally there may be some additional options that are specific to each function. To change these you will need to explicitly state all other arguments
 
@@ -84,10 +88,10 @@ void setup() {
     myTFT.line(2,12, 126,12, 4, (color_t)colorArray, CCLength, indi); // Notice that it is okay for startColorOffset to exceed colorCycleLength
     delay(20);
   }
-  myTFT.clearDisplay(); 
+  myTFT.clearDisplay();
 
 
-  // Color cycles work in two ways for rectangles: 
+  // Color cycles work in two ways for rectangles:
   // For a non-filled rectangle the cycle goes around the perimeter, and you can reverse the direction. It always starts from the upper-left corner
   // For a filled rectangle the color cycle is used to create either a horizontal or vertical gradient, both of which can be reversed
   const uint8_t rectCCLength = 60;
@@ -98,26 +102,26 @@ void setup() {
     rectColorArray[indi].b = 0x00;
   }
   // Color cycles and options for rectangles:
-  myTFT.rectangle(3, 3, 124, 156, false, (color_t)rectColorArray, rectCCLength, 0);               // Makes a non-filled rectablge around the whole screen 
+  myTFT.rectangle(3, 3, 124, 156, false, (color_t)rectColorArray, rectCCLength, 0);               // Makes a non-filled rectablge around the whole screen
   myTFT.rectangle(0, 0, 127, 159, false, (color_t)rectColorArray, rectCCLength, 0, true);         // Makes a non-filled rectablge around the whole screen with the cycle going in the other direction
   myTFT.rectangle(6, 6, 60, 76, true, (color_t)rectColorArray, rectCCLength, 0);                  // Makes a filled rectangle that defaults to a non-reversed horizontal gradient (the color cycle is the gradient)
   myTFT.rectangle(68, 6, 121, 76, true, (color_t)rectColorArray, rectCCLength, 0, true);          // Makes a filled rectangle with a horizontal gradient that is reversed
   myTFT.rectangle(6, 84, 60, 153, true, (color_t)rectColorArray, rectCCLength, 0, false, true);   // Makes a filled rectangle with a non-reversed vertical gradient
   myTFT.rectangle(68, 84, 121, 153, true, (color_t)rectColorArray, rectCCLength, 0, true, true);  // Makes a filled rectangle with a vertical gradient that is reversed
   delay(5000);
-  myTFT.clearDisplay(); 
+  myTFT.clearDisplay();
 
 
 
   // Another HyperDisplay feature not discussed in Example2 is the "polygon" function(s).
-  // Polygon will automatically draw several connected lines when given the coordinates in a list. 
+  // Polygon will automatically draw several connected lines when given the coordinates in a list.
   // The main advantages are simplicity and the fact that a color cycle can run uninterrupted through the whole polygon.
-  hd_extent_t xCoords[] = {64, 127,  0, 127,   0};  
+  hd_extent_t xCoords[] = {64, 127,  0, 127,   0};
   hd_extent_t yCoords[] = {24, 120, 60,  60, 120};
   if(sizeof(xCoords) != sizeof(yCoords)){
     SERIAL_PORT.println("Coordinate array dimensions mismatch. Please make xCoords and yCoords have the same number of elements. Freezing");
     while(1){};
-  }  
+  }
   myTFT.polygon(xCoords, yCoords, sizeof(xCoords)/sizeof(hd_extent_t), 1, (color_t)rectColorArray, rectCCLength, 0, false); // You can choose the width (3 here) and whether or not to reverse the gradient direction too
   delay(5000);
   myTFT.clearDisplay();
@@ -144,15 +148,15 @@ void setup() {
     color_t         data;                     // A pointer to pixel data that is specific to the window. Can be left as NULL
     hd_pixels_t    numPixels;                 // The number of pixel types that data points to
     bool            dynamic;                  // Indicator if the current buffer memory was dynamically allocated - so that it can be disposed of automatically
-  }wind_info_t;                        // Window infomation structure for placing objects on the display 
+  }wind_info_t;                        // Window infomation structure for placing objects on the display
   */
   // You'll notice that the window structure handles min/max extent values, current cursor values, reset cursor values, character info, and color cycle info
 
-  // In previous examples we never mentioned windows and that's OK because the default window covers the entire screen. 
+  // In previous examples we never mentioned windows and that's OK because the default window covers the entire screen.
   // Now we will do a few demos with windows...
 
   wind_info_t wind1, wind2, wind3;  // Create several window objects
-  ILI9163C_color_18_t color1, color2, color3; 
+  ILI9163C_color_18_t color1, color2, color3;
 
   // Initialize the windows to defualt settings (this is a pretty important step unless you are extra careful to manually initialize each and every paramter)
   myTFT.setWindowDefaults(&wind1);
@@ -162,17 +166,17 @@ void setup() {
   color1.r = 0xFF;    // Set the colors to red, green, and blue respectively
   color1.g = 0x00;
   color1.b = 0x00;
-  
+
   color2.r = 0x00;
   color2.g = 0xFF;
   color2.b = 0x00;
-  
-  color3.r = 0x00; 
+
+  color3.r = 0x00;
   color3.g = 0x00;
   color3.b = 0xFF;
 
   // Now we will set up the boundaries of the windows, the cursor locations, and their default colors
-  wind1.xMin = 0; 
+  wind1.xMin = 0;
   wind1.yMin = 0;
   wind1.xMax = 62;
   wind1.yMax = 78;
@@ -182,9 +186,9 @@ void setup() {
   wind1.yReset = 1;
   wind1.currentSequenceData = (color_t)&color1;
   wind1.currentColorCycleLength = 1;
-  wind1.currentColorOffset = 0; 
+  wind1.currentColorOffset = 0;
 
-  wind2.xMin = 65; 
+  wind2.xMin = 65;
   wind2.yMin = 0;
   wind2.xMax = 127;
   wind2.yMax = 78;
@@ -194,9 +198,9 @@ void setup() {
   wind2.yReset = 15;
   wind2.currentSequenceData = (color_t)&color2;
   wind2.currentColorCycleLength = 1;
-  wind2.currentColorOffset = 0; 
-  
-  wind3.xMin = 0; 
+  wind2.currentColorOffset = 0;
+
+  wind3.xMin = 0;
   wind3.yMin = 81;
   wind3.xMax = 127;
   wind3.yMax = 159;
@@ -206,9 +210,9 @@ void setup() {
   wind3.yReset = 1;
   wind3.currentSequenceData = (color_t)&color3;
   wind3.currentColorCycleLength = 1;
-  wind3.currentColorOffset = 0; 
-  
-  // All hyperdisplay drawing functions are applied to the current window, and the coordinates are with respect to the window. 
+  wind3.currentColorOffset = 0;
+
+  // All hyperdisplay drawing functions are applied to the current window, and the coordinates are with respect to the window.
   // To demonstrate this we will use the same exact drawing function to draw in each of the three windows, each with to unique effect
   wind_info_t* windowPointers[] = {&wind1, &wind2, &wind3};
   for(uint8_t indi = 0; indi < 3; indi++){
@@ -224,15 +228,15 @@ void setup() {
   }
   delay(5000);
 
-  // And lastly, the printing functions are impacted by windows. 
+  // And lastly, the printing functions are impacted by windows.
   for(uint8_t indi = 0; indi < 3; indi++){
     myTFT.pCurrentWindow = windowPointers[indi];                  // Set the current window
     myTFT.setCurrentWindowColorSequence((color_t)&defaultColor);  // Change each window's color to the white value we defined at the beginning
     myTFT.println("You see, each window handles printed text on its own!");
 
     myTFT.print("Done!");
   }
-  
+
   SERIAL_PORT.println("Done!");
   myTFT.println("\n\nDone!");
 }