Added scaled+rotated text drawing

Author: Laurence Bank

README.md

@@ -34,6 +34,7 @@ Features:<br>
 - Text cursor position with optional line wrap<br>
 - a function to load a Windows BMP file<br>
 - Pixel drawing on SH1106/7 without needing backing RAM<br>
+- Draw text into the back buffer at any scale and rotation (in 90 deg increments)<br>
 - Optimized Bresenham line drawing<br>
 - Optimized Bresenham outline and filled ellipse drawing<br>
 - Optimized outline and filled rectangle drawing<br>

examples/ss_oled_test/ss_oled_test.ino

@@ -3,17 +3,35 @@
 // Arduino Pro Mini
 // Pin 8 (0xb0 = PORTB, bit 0)
 // Pin 9 (0xb1 = PORTB, bit 1)
-#define SDA_PIN 0xb0
-#define SCL_PIN 0xb1
+// UnexpectedMaker TinyPICO
+#define SDA_PIN 21
+#define SCL_PIN 22
+
 #define RESET_PIN -1
+#define FLIPPED 1
+#define INVERTED 0
+// Use bit banging to get higher speed output
+#define HARDWARE_I2C 0
+#define WIDTH 128
+#define HEIGHT 64
 int rc;
 SSOLED oled;
+
+// Use a 1K back buffer to do access more complex features on systems with
+// more RAM available. This can work on AVR, but will use most of the RAM
+#ifndef __AVR__
+static uint8_t ucBuffer[1024];
+#endif // __AVR__
+
 void setup() {
 uint8_t uc[8];
 
-  rc = oledInit(&oled, OLED_128x64, 0x3c, 0, 0, 0, SDA_PIN, SCL_PIN, RESET_PIN, 1000000L);
+  rc = oledInit(&oled, OLED_128x64, 0x3c, FLIPPED, INVERTED, HARDWARE_I2C, SDA_PIN, SCL_PIN, RESET_PIN, 1000000L);
   if (rc != OLED_NOT_FOUND)
-  { 
+  {
+    #ifndef __AVR__
+    oledSetBackBuffer(&oled, ucBuffer);
+    #endif
     oledFill(&oled, 0,1);
     oledSetContrast(&oled, 127);
     oledWriteString(&oled, 0,0,0,(char *)"**************** ", FONT_8x8, 0, 1);
@@ -38,21 +56,21 @@ char szTemp[32];
   oledWriteString(&oled, 0,0,2,(char *)"16x32 and a new", FONT_8x8, 0, 1);
   oledWriteString(&oled, 0,0,3,(char *)"Stretched", FONT_12x16, 0, 1);
   oledWriteString(&oled, 0,0,5,(char *)"from 6x8", FONT_12x16, 0, 1);
-  delay(10000);
+  delay(5000);
 
   oledFill(&oled, 0, 1);
   oledSetTextWrap(&oled, 1);
-  oledWriteString(&oled, 0,-1,-1,"This is a test of text wrap", FONT_6x8, 0, 1);
+  oledWriteString(&oled, 0,-1,-1,(char *)"This is a test of text wrap", FONT_6x8, 0, 1);
   delay(3000);
   oledFill(&oled, 0,1);
 //  oledSetTextWrap(0);
-  oledWriteString(&oled, 0,-1,-1,"This ", FONT_16x16, 0, 1);
-  oledWriteString(&oled, 0,-1,-1,"is a ", FONT_16x16, 0, 1);
-  oledWriteString(&oled, 0,-1,-1,"test of text wrap", FONT_16x16, 0, 1);
+  oledWriteString(&oled, 0,-1,-1,(char *)"This ", FONT_16x16, 0, 1);
+  oledWriteString(&oled, 0,-1,-1,(char *)"is a ", FONT_16x16, 0, 1);
+  oledWriteString(&oled, 0,-1,-1,(char *)"test of text wrap", FONT_16x16, 0, 1);
   delay(3000);
   oledFill(&oled, 0,1);
   oledSetCursor(&oled, 40,4);
-  oledWriteString(&oled, 0,-1,-1,"Middle", FONT_6x8,0,1);
+  oledWriteString(&oled, 0,-1,-1,(char *)"Middle", FONT_6x8,0,1);
   delay(3000);
   if (rc >= OLED_SH1106_3C)          // We can set pixels on the SH1106 without a back buffer
   {
@@ -67,6 +85,43 @@ char szTemp[32];
   }
 #ifndef __AVR__
 
+  for (int iRot=ROT_0; iRot <= ROT_270; iRot++) {
+    for (int i=128; i<1280; i+=64) {
+      oledFill(&oled, 0, 0);
+      oledScaledString(&oled, WIDTH/2, HEIGHT/2, (char *)"Hello", FONT_SMALL, 0, i, i, iRot);
+      oledDumpBuffer(&oled, NULL);
+    }
+    for (int i=1280; i>=128; i-=64) {
+      oledFill(&oled, 0, 0);
+      oledScaledString(&oled, WIDTH/2, HEIGHT/2, (char *)"Hello", FONT_SMALL, 0, 1280, i, iRot);
+      oledDumpBuffer(&oled, NULL);
+    }
+    for (int i=1280; i>=128; i-=64) {
+      oledFill(&oled, 0, 0);
+      oledScaledString(&oled, WIDTH/2, HEIGHT/2, (char *)"Hello", FONT_SMALL, 0, i, 128, iRot);
+      oledDumpBuffer(&oled, NULL);
+    }
+  }
+  delay(2000);
+
+// Rotated Text
+  oledFill(&oled, 0, 1);
+  oledWriteString(&oled, 0, 0, 0, (char *)"Rotated", FONT_NORMAL, 0, 1);
+  oledWriteString(&oled, 0, 0, 1, (char *)"Text", FONT_NORMAL, 0, 1);
+  delay(2000);
+
+  for (int iRot = ROT_0; iRot <= ROT_270; iRot++) {
+    oledFill(&oled, 0, 1);
+    for (i = 0; i<40; i++) {
+       int x, y;
+       x = random(WIDTH);
+       y = random(HEIGHT);
+       oledScaledString(&oled, x, y, (char *)"Rotated Text", FONT_8x8, 0, 256, 256, iRot);
+       oledDumpBuffer(&oled, NULL);
+    } // for i
+    delay(2000);
+  } // for iRot
+
   for (i=0; i<8; i++)
   {
     sprintf(szTemp, "Line %d", i);

library.properties

@@ -1,5 +1,5 @@
 name=ss_oled
-version=4.2.1
+version=4.3.1
 author=Larry Bank
 maintainer=Larry Bank
 sentence=Small and simple OLED display library.

src/ss_oled.cpp

@@ -2045,6 +2045,98 @@ void oledDrawLine(SSOLED *pOLED, int x1, int y1, int x2, int y2, int bRender)
   } // y major case
 } /* oledDrawLine() */
 
+//
+// Draw a string with a fractional scale in both dimensions
+// the scale is a 16-bit integer with and 8-bit fraction and 8-bit mantissa
+// To draw at 1x scale, set the scale factor to 256. To draw at 2x, use 512
+// The output must be drawn into a memory buffer, not directly to the display
+//
+int oledScaledString(SSOLED *pOLED, int x, int y, char *szMsg, int iSize, int bInvert, int iXScale, int iYScale, int iRotation)
+{
+uint32_t row, col, dx, dy;
+uint32_t sx, sy;
+uint8_t c, uc, color, *d;
+const uint8_t *s;
+uint8_t ucTemp[16];
+int tx, ty, bit, iFontOff;
+int iPitch, iOffset;
+int iFontWidth;
+
+   if (iXScale == 0 || iYScale == 0 || szMsg == NULL || pOLED == NULL || pOLED->ucScreen == NULL || x < 0 || y < 0 || x >= pOLED->oled_x-1 || y >= pOLED->oled_y-1)
+      return -1; // invalid display structure
+   if (iSize != FONT_8x8 && iSize != FONT_6x8)
+      return -1; // only on the small fonts (for now)
+   iFontWidth = (iSize == FONT_6x8) ? 6:8;
+   s = (iSize == FONT_6x8) ? ucSmallFont : ucFont;
+   iPitch = pOLED->oled_x;
+   dx = (iFontWidth * iXScale) >> 8; // width of each character
+   dy = (8 * iYScale) >> 8; // height of each character
+   sx = 65536 / iXScale; // turn the scale into an accumulator value
+   sy = 65536 / iYScale;
+   while (*szMsg) {
+      c = *szMsg++; // debug - start with normal font
+      iFontOff = (int)(c-32) * (iFontWidth-1);
+      // we can't directly use the pointer to FLASH memory, so copy to a local buffer
+      ucTemp[0] = 0; // first column is blank
+      memcpy_P(&ucTemp[1], &s[iFontOff], iFontWidth-1);
+      if (bInvert) InvertBytes(ucTemp, iFontWidth);
+      col = 0;
+      for (tx=0; tx<(int)dx; tx++) {
+         row = 0;
+         uc = ucTemp[col >> 8];
+         for (ty=0; ty<(int)dy; ty++) {
+            int nx, ny;
+            bit = row >> 8;
+            color = (uc & (1 << bit)); // set or clear the pixel
+            switch (iRotation) {
+               case ROT_0:
+                  nx = x + tx;
+                  ny = y + ty;
+                  break;
+               case ROT_90:
+                  nx = x - ty;
+                  ny = y + tx;
+                  break;
+               case ROT_180:
+                  nx = x - tx;
+                  ny = y - ty;
+                  break;
+               case ROT_270:
+                  nx = x + ty;
+                  ny = y - tx;
+                  break;
+            } // switch on rotation direction
+            // plot the pixel if it's within the image boundaries
+            if (nx >= 0 && ny >= 0 && nx < pOLED->oled_x && ny < pOLED->oled_y) {
+               d = &pOLED->ucScreen[(ny >> 3) * iPitch + nx];
+               if (color)
+                  d[0] |= (1 << (ny & 7));
+               else
+                  d[0] &= ~(1 << (ny & 7));
+            }
+            row += sy; // add fractional increment to source row of character
+         } // for ty
+         col += sx; // add fractional increment to source column
+      } // for tx
+      // update the 'cursor' position
+      switch (iRotation) {
+         case ROT_0:
+            x += dx;
+            break;
+         case ROT_90:
+            y += dx;
+            break;
+         case ROT_180:
+            x -= dx;
+            break;
+         case ROT_270:
+            y -= dx;
+            break;
+      } // switch on rotation
+   } // while (*szMsg)
+   return 0;
+} /* oledScaledString() */
+
 //
 // For drawing ellipses, a circle is drawn and the x and y pixels are scaled by a 16-bit integer fraction
 // This function draws a single pixel and scales its position based on the x/y fraction of the ellipse

src/ss_oled.h

@@ -29,6 +29,14 @@ enum {
    FONT_16x16,
    FONT_16x32
 };
+// 4 possible rotation angles for oledScaledString()
+enum {
+   ROT_0=0,
+   ROT_90,
+   ROT_180,
+   ROT_270
+};
+
 #define FONT_NORMAL FONT_8x8
 #define FONT_SMALL FONT_6x8
 #define FONT_LARGE FONT_16x32
@@ -128,6 +136,13 @@ void oledSetTextWrap(SSOLED *pOLED, int bWrap);
 //
 int oledWriteString(SSOLED *pOLED, int iScrollX, int x, int y, char *szMsg, int iSize, int bInvert, int bRender);
 //
+// Draw a string with a fractional scale in both dimensions
+// the scale is a 16-bit integer with and 8-bit fraction and 8-bit mantissa
+// To draw at 1x scale, set the scale factor to 256. To draw at 2x, use 512
+// The output must be drawn into a memory buffer, not directly to the display
+//
+int oledScaledString(SSOLED *pOLED, int x, int y, char *szMsg, int iSize, int bInvert, int iXScale, int iYScale, int iRotation);
+//
 // Fill the frame buffer with a byte pattern
 // e.g. all off (0x00) or all on (0xff)
 //