finished impl/port for example 2

Author: Kirk

examples/Example-01_Hello/Example-01_Hello.ino

@@ -118,11 +118,10 @@ void setup()
     // Do a simple test - fill a rectangle on the screen and then print hello!
 
     // fill a rectangle on the screen that has a 4 pixel board
-
     myOLED.rectangleFill(4, 4, myOLED.getWidth()-4, myOLED.getHeight()-4);
 
     String hello = "hello"; // our message
-    
+
     // Lets center our message on the screen. We need to current font. 
 
     QwiicFont * pFont = myOLED.getFont();

examples/Example-02_Shapes/Example-02_Shapes.ino

@@ -1,61 +1,110 @@
-/*
-  MicroOLED_Hello.ino
-  SFE_MicroOLED Hello World Demo
-  Jim Lindblom @ SparkFun Electronics
-  Original Creation Date: October 26, 2014
-  
-  This sketch lights up a familiar pattern on the MicroOLED
-  Breakout. It's a great way to prove you've connected everything
-  correctly and that your display is in working order.
-  
-  Hardware Connections:
-    This example assumes you are using Qwiic. See the SPI examples for
-    a detailed breakdown of connection info.
-  
-  Note: The display on the MicroOLED is a 1.8V-3.3V device only.
-  Don't try to connect a 5V Arduino directly to it! Use level
-  shifters in between the data signals if you have to resort to
-  a 5V board.
-  
-  This code is beerware; if you see me (or any other SparkFun 
-  employee) at the local, and you've found our code helpful, 
-  please buy us a round!
-  
-  Distributed as-is; no warranty is given.
-*/
+
+// Example-02_Shapes.ino
+// 
+// This is a library written for SparkFun Qwiic OLED boards that use the SSD1306.
+//
+// SparkFun sells these at its website: www.sparkfun.com
+//
+// Do you like this library? Help support SparkFun. Buy a board!
+//
+//   Micro OLED             https://www.sparkfun.com/products/14532
+//   Transparent OLED       https://www.sparkfun.com/products/15173
+//   "Narrow" OLED          https://www.sparkfun.com/products/17153
+// 
+// 
+// Written by Kirk Benell @ SparkFun Electronics, March 2022
+//
+// This library configures and draws graphics to OLED boards that use the 
+// SSD1306 display hardware. The library only supports I2C.
+// 
+// Repository:
+//     https://github.com/sparkfun/SparkFun_Qwiic_OLED_Arduino_Library
+//
+// Documentation:
+//     https://sparkfun.github.io/SparkFun_Qwiic_OLED_Arduino_Library/
+//
+//
+// SparkFun code, firmware, and software is released under the MIT License(http://opensource.org/licenses/MIT).
+//
+// SPDX-License-Identifier: MIT
+//
+//    The MIT License (MIT)
+//
+//    Copyright (c) 2022 SparkFun Electronics
+//    Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+//    associated documentation files (the "Software"), to deal in the Software without restriction,
+//    including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+//    and/or sell copies of the Software, and to permit persons to whom the Software is furnished to
+//    do so, subject to the following conditions:
+//    The above copyright notice and this permission notice shall be included in all copies or substantial
+//    portions of the Software.
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+//    NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+//    IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+//    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+//    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+//////////////////////////////////////////////////////////////////////////////////////////
+// Example 2 for the SparkFun Qwiic OLED Arduino Library
+//
+// >> Overview <<
+//
+// This demo shows the various methods available for drawing shapes using the OLED library
+//
+//////////////////////////////////////////////////////////////////////////////////////////
+//
+// >>> SELECT THE CONNECTED DEVICE FOR THIS EXAMPLE <<<
+//
+// The Library supports three different types of SparkFun boards. The demo uses the following
+// defines to determine which device is being used. Uncomment the device being used for this demo.
+//
+// The default is Micro OLED
+
+#define MICRO
+//#define NARROW
+//#define TRANSPARENT
+
+//////////////////////////////////////////////////////////////////////////////////////////
 
 #include <stdint.h>
 
 // Include the SparkFun qwiic OLED Library
 #include <SparkFun_Qwiic_OLED.h>
 
-#define MICRO
-//#define NARROW
+// What device is being used in this demo
 
-#if defined(MICRO)
-QwiicMicroOLED myOLED;
-const char * deviceName = "Micro OLED";
+#if defined(TRANSPARENT)
+QwiicTransparentOLED myOLED;
+const char * deviceName = "Transparent OLED";
 
 #elif defined(NARROW)
-QwiccNarrowOLED myOLED;
+QwiicNarrowOLED myOLED;
 const char * deviceName = "Narrow OLED";
 
 #else
-QwiicTransparentOLED myOLED;
-const char * deviceName = "Transparent OLED";
-#endif
-
+QwiicMicroOLED myOLED;
+const char * deviceName = "Micro OLED";
 
-//#include "res/qw_fnt_5x7.h"
-#include <res/qw_fnt_8x16.h>
-//#include "res/qw_fnt_7segment.h"
-//#include "res/qw_fnt_31x48.h"
-//#include "res/qw_fnt_largenum.h"
+#endif
 
+// Global variables - used to stash our screen size
 
 int width;
 int height;
 
+////////////////////////////////////////////////////////////////////////////////
+// line_test_1() 
+//
+// This test draws a horizontal line on the screen, moving it from the 
+// top of the screen to the bottom. 
+//
+// This sequence repeats multiple times, starting with a small line and 
+// growing to the width of the screen.
+//
+// Since the library uses a "dirty range" methodology to minimize the amount of 
+// data sent to the device, as the lenght of the line increases, the rate 
+// of the display updates also decreases.  A longer line, results in more data being
+// sent to the display. 
 
 void line_test_1(void){
 
@@ -80,6 +129,13 @@ void line_test_1(void){
 
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// line_test_2() 
+//
+// This test draws a series of lines bursting out from the corner of the display. 
+//
+// It demostrates the abilty of the library to draw arbitray straight lines.
+
 void line_test_2(void){
 
     for(int i=0; i < width; i +=6){
@@ -94,18 +150,31 @@ void line_test_2(void){
     }    
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// line_test_vert() 
+//
+// Draws a series of vertical lines, some horz lines and two diag lines.
+//
+// Internally, this uses the standard line algorithm  (diag), fast horz and fast
+// vertical lines functions. 
+//
+// Iterator function - called to animate graphic
 void line_test_vert_iter(uint8_t y0, uint8_t y1){
 
     for(int i=0; i < width; i += 8)
         myOLED.line( i, y0, i, y1);
 
+    // end off the vertical lines
     myOLED.line( width-1, y0, width-1, y1);        
 
+    // End lines and cross lines
     myOLED.line(0, y0, width-1, y0);
     myOLED.line(0, y1, width-1, y1);
     myOLED.line(0, y0, width-1, y1);
     myOLED.line(0, y1, width-1, y0);    
 }
+
+// Entry point for test
 void line_test_vert(void){
 
     int mid = height/2;
@@ -119,12 +188,21 @@ void line_test_vert(void){
     }
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// rect_test() 
+//
+// Simple - draw a rectangle test
 void rect_test(void){
 
     myOLED.rectangle(4, 4, width-4, height-4);
 
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// rect_test_move() 
+//
+// Draws a rectangle, then moves it across the screen
+//
 void rect_test_move(void){    
 
     float steps = height;
@@ -133,13 +211,14 @@ void rect_test_move(void){
     int side = 10;
     float x = 0;
     float y = 0;
+
     for(int i = 0; i < steps; i++){
 
+        // Draw the rectangle and send it to device
         myOLED.rectangle(x, y, x+side, y+side);
-        myOLED.display();
-        //delay(100);
+        myOLED.display(); // sends erased rect and new rect pixels to device
 
-        // Erase the that rect
+        // Erase the that rect, increment and loop
         myOLED.rectangle(x, y, x+side, y+side, 0);
 
         x += xinc;
@@ -148,17 +227,27 @@ void rect_test_move(void){
 
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// rect_fill_test() 
+//
+// Draws two filled rectangles, switches to XOR draw mode and overwrites them 
+// with another rectangle
+
 void rect_fill_test(void){
 
     myOLED.rectangleFill(4, 4, width/2-4, height-4);
 
     myOLED.rectangleFill(width/2+4, 4, width-4, height-4);
 
-    myOLED.setDrawMode(grROPXOR);
+    myOLED.setDrawMode(grROPXOR);   // xor
     myOLED.rectangleFill(width/4, 8, width - width/4, height-8);
-    myOLED.setDrawMode(grROPCopy);        
+    myOLED.setDrawMode(grROPCopy);  // back to copy op (default)
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// circle_test() 
+//
+// Draw a series of circles - filled and not filled
 void circle_test(void){
 
     myOLED.circle(width/4, height/2, height/3);
@@ -167,21 +256,15 @@ void circle_test(void){
 
     myOLED.circle(4, height/2, height/3);
 
-    myOLED.circleFill(width - width/4 , height/2, height/3);    
+    myOLED.circleFill(width - width/2 , height/2, height/4);    
 
-    myOLED.setDrawMode(grROPXOR);
-    myOLED.circleFill(width - width/4 - height/4, height/2, height/3); // bug in here
-    myOLED.setDrawMode(grROPCopy);    
 }
 
-void text_hello(void){
-
-    myOLED.text(10, 10 , "Hello World");
 
-    myOLED.setDrawMode(grROPXOR);
-    myOLED.rectangleFill(8, 8, width/2, height/2);
-    myOLED.setDrawMode(grROPCopy);    
-}
+// Make an array of function pointers - used to hold the list of tests to run.
+// 
+// Makes the loop call to each test function simple.
+//
 // testing function table
 typedef void (*testFn)(void);
 
@@ -192,53 +275,56 @@ static const testFn testFunctions[] = {
     rect_test,
     rect_test_move,
     rect_fill_test,
-    circle_test,
-    text_hello
+    circle_test
 }; 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////
+// setup()
+// 
+// Standard Arduino setup routine
+
 void setup()
 {
     delay(100);   //Give display time to power on
     Serial.begin(115200);
 
     Serial.println("\n\r-----------------------------------");
 
-    Serial.print("Running Test #1 on: ");
+    Serial.print("Running Test #2 on: ");
     Serial.println(String(deviceName));
 
     if(!myOLED.begin()){
 
-        Serial.println("Device Begin Failed");
+        Serial.println("- Device Begin Failed");
         while(1);
     }
 
-    Serial.println("- Begin Success");
+    Serial.println("- Begin Successful");
 
+    // save device dims for the test routines
     width = myOLED.getWidth();
     height = myOLED.getHeight();
-
-//    myOLED.set_font(QW_FONT_5X7);    // works
-    myOLED.setFont(QW_FONT_8X16);   // works
-//    myOLED.set_font(QW_FONT_31X48);   // works
- //   myOLED.set_font(QW_FONT_LARGENUM);   // works    
-
-//    myOLED.set_font(QW_FONT_7SEGMENT);        // works
-
 
 }
 
+////////////////////////////////////////////////////////////////////////////////////////////////
+// loop()
+//
+// Standard Arduino loop function.
 
 void loop(){
 
+    // Just loop over our test functions
     for(uint8_t i=0; i < sizeof(testFunctions)/sizeof(testFunctions[0]); i++){
 
         myOLED.erase();
-        testFunctions[i]();
+
+        testFunctions[i](); // next function
+        
         myOLED.display();
+
         delay(1000);
 
     }
-    Serial.println(">>>>>> End Test Loop <<<<<<");
-    delay(1000);
+
 }