Reducing size of data send in one frame & update Zen rev2 oled usage

docs/feature_oled_driver.md

@@ -56,7 +56,7 @@ In split keyboards, it is very common to have two OLED displays that each render
 
 ```C++
 #ifdef OLED_DRIVER_ENABLE
-uint8_t oled_init_user(uint8_t rotation) {
+oled_rotation_t oled_init_user(oled_rotation_t rotation) {
   if (!is_keyboard_master())
     return OLED_ROTATION_180;  // flips the display 180 degrees if offhand
   return rotation;
@@ -99,18 +99,28 @@ void oled_task_user(void) {
 |`OLED_DISPLAY_WIDTH`   |`128`          |The width of the OLED display.                                   |
 |`OLED_DISPLAY_HEIGHT`  |`32`           |The height of the OLED display.                                  |
 |`OLED_MATRIX_SIZE`     |`512`          |The local buffer size to allocate.<br />`(OLED_DISPLAY_HEIGHT / 8 * OLED_DISPLAY_WIDTH)`|
-|`OLED_BLOCK_TYPE`      |`uint8_t`      |The unsigned integer type to use for dirty rendering.|
+|`OLED_BLOCK_TYPE`      |`uint16_t`     |The unsigned integer type to use for dirty rendering.|
-|`OLED_BLOCK_COUNT`     |`8`            |The number of blocks the display is divided into for dirty rendering.<br />`(sizeof(OLED_BLOCK_TYPE) * 8)`|
+|`OLED_BLOCK_COUNT`     |`16`           |The number of blocks the display is divided into for dirty rendering.<br />`(sizeof(OLED_BLOCK_TYPE) * 8)`|
-|`OLED_BLOCK_SIZE`      |`64`           |The size of each block for dirty rendering<br />`(OLED_MATRIX_SIZE / OLED_BLOCK_COUNT)`|
+|`OLED_BLOCK_SIZE`      |`32`           |The size of each block for dirty rendering<br />`(OLED_MATRIX_SIZE / OLED_BLOCK_COUNT)`|
 |`OLED_SOURCE_MAP`      |`{ 0, ... N }` |Precalculated source array to use for mapping source buffer to target OLED memory in 90 degree rendering.         |
-|`OLED_TARGET_MAP`      |`{ 48, ... N }`|Precalculated target array to use for mapping source buffer to target OLED memory in 90 degree rendering.         |
+|`OLED_TARGET_MAP`      |`{ 24, ... N }`|Precalculated target array to use for mapping source buffer to target OLED memory in 90 degree rendering.         |
 
 
 ### 90 Degree Rotation - Technical Mumbo Jumbo 
 
+```C
+// OLED Rotation enum values are flags
+typedef enum {
+    OLED_ROTATION_0   = 0,
+    OLED_ROTATION_90  = 1,
+    OLED_ROTATION_180 = 2,
+    OLED_ROTATION_270 = 3, // OLED_ROTATION_90 | OLED_ROTATION_180
+} oled_rotation_t;
+```
+
  OLED displays driven by SSD1306 drivers only natively support in hard ware 0 degree and 180 degree rendering. This feature is done in software and not free. Using this feature will increase the time to calculate what data to send over i2c to the OLED. If you are strapped for cycles, this can cause keycodes to not register. In testing however, the rendering time on an `atmega32u4` board only went from 2ms to 5ms and keycodes not registering was only noticed once we hit 15ms. 
  
- 90 Degree Rotated Rendering is achieved by using bitwise operations to rotate each 8 block of memory and uses two precalculated arrays to remap buffer memory to OLED memory. The memory map defines are precalculated for remap performance and are calculated based on the OLED Height, Width, and Block Size. For example, in the default 128x32 implementation we have a 64 byte block size. This gives us eight 8 byte blocks that need to be rotated and rendered. The OLED renders horizontally two 8 byte blocks before moving down a page, e.g:
+ 90 Degree Rotated Rendering is achieved by using bitwise operations to rotate each 8 block of memory and uses two precalculated arrays to remap buffer memory to OLED memory. The memory map defines are precalculated for remap performance and are calculated based on the OLED Height, Width, and Block Size. For example, in the 128x32 implementation with a `uint8_t` block type, we have a 64 byte block size. This gives us eight 8 byte blocks that need to be rotated and rendered. The OLED renders horizontally two 8 byte blocks before moving down a page, e.g:
 
 |   |   |   |   |   |   |
 |---|---|---|---|---|---|
@@ -133,14 +143,22 @@ So those precalculated arrays just index the memory offsets in the order in whic
 ## OLED API
 
 ```C++
-// Initialize the OLED display, rotating the rendered output 180 degrees if true.
+// OLED Rotation enum values are flags
+typedef enum {
+    OLED_ROTATION_0   = 0,
+    OLED_ROTATION_90  = 1,
+    OLED_ROTATION_180 = 2,
+    OLED_ROTATION_270 = 3, // OLED_ROTATION_90 | OLED_ROTATION_180
+} oled_rotation_t;
+
+// Initialize the OLED display, rotating the rendered output based on the define passed in.
 // Returns true if the OLED was initialized successfully
-bool oled_init(bool flip180);
+bool oled_init(oled_rotation_t rotation);
 
 // Called at the start of oled_init, weak function overridable by the user
-// flip180 - the value passed into oled_init
+// rotation - the value passed into oled_init
-// Return true if you want the oled to be flip180
+// Return new oled_rotation_t if you want to override default rotation
-bool oled_init_user(bool flip180);
+oled_rotation_t oled_init_user(oled_rotation_t rotation);
 
 // Clears the display buffer, resets cursor position to 0, and sets the buffer to dirty for rendering
 void oled_clear(void);
@@ -217,7 +235,7 @@ bool oled_scroll_off(void);
 // Returns the maximum number of characters that will fit on a line
 uint8_t oled_max_chars(void);
 
-// Returns the maximum number of lines that will fit on the oled
+// Returns the maximum number of lines that will fit on the OLED
 uint8_t oled_max_lines(void);
 ```
 

drivers/oled/oled_driver.c

@@ -203,7 +203,7 @@ bool oled_init(uint8_t rotation) {
 }
 
 __attribute__((weak))
-uint8_t oled_init_user(uint8_t rotation) {
+oled_rotation_t oled_init_user(oled_rotation_t rotation) {
   return rotation;
 }
 
@@ -384,7 +384,10 @@ void oled_write_char(const char data, bool invert) {
 
   // Dirty check
   if (memcmp(&oled_temp_buffer, oled_cursor, OLED_FONT_WIDTH)) {
-    oled_dirty |= (1 << ((oled_cursor - &oled_buffer[0]) / OLED_BLOCK_SIZE));
+    uint16_t index = oled_cursor - &oled_buffer[0];
+    oled_dirty |= (1 << (index / OLED_BLOCK_SIZE));
+    // Edgecase check if the written data spans the 2 chunks
+    oled_dirty |= (1 << ((index + OLED_FONT_WIDTH) / OLED_BLOCK_SIZE));
   }
 
   // Finally move to the next char

drivers/oled/oled_driver.h

@@ -27,14 +27,17 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
   #define OLED_DISPLAY_WIDTH 128
   #define OLED_DISPLAY_HEIGHT 64
   #define OLED_MATRIX_SIZE (OLED_DISPLAY_HEIGHT / 8 * OLED_DISPLAY_WIDTH) // 1024 (compile time mathed)
-  #define OLED_BLOCK_TYPE uint16_t
+  #define OLED_BLOCK_TYPE uint32_t
-  #define OLED_BLOCK_COUNT (sizeof(OLED_BLOCK_TYPE) * 8) // 16 (compile time mathed)
+  #define OLED_BLOCK_COUNT (sizeof(OLED_BLOCK_TYPE) * 8) // 32 (compile time mathed)
-  #define OLED_BLOCK_SIZE (OLED_MATRIX_SIZE / OLED_BLOCK_COUNT) // 64 (compile time mathed)
+  #define OLED_BLOCK_SIZE (OLED_MATRIX_SIZE / OLED_BLOCK_COUNT) // 32 (compile time mathed)
 
   // For 90 degree rotation, we map our internal matrix to oled matrix using fixed arrays
   // The OLED writes to it's memory horizontally, starting top left, but our memory starts bottom left in this mode
-  #define OLED_SOURCE_MAP { 0, 8, 16, 24, 32, 40, 48, 56 }
+  #define OLED_SOURCE_MAP { 32, 40, 48, 56 }
-  #define OLED_TARGET_MAP { 56, 48, 40, 32, 24, 16, 8, 0 }
+  #define OLED_TARGET_MAP { 24, 16, 8, 0 }
+  // If OLED_BLOCK_TYPE is uint16_t, these tables would look like:
+  // #define OLED_SOURCE_MAP { 0, 8, 16, 24, 32, 40, 48, 56 }
+  // #define OLED_TARGET_MAP { 56, 48, 40, 32, 24, 16, 8, 0 }
   // If OLED_BLOCK_TYPE is uint8_t, these tables would look like:
   // #define OLED_SOURCE_MAP { 0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120 }
   // #define OLED_TARGET_MAP { 56, 120, 48, 112, 40, 104, 32, 96, 24, 88, 16, 80, 8, 72, 0, 64 }
@@ -43,14 +46,17 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
   #define OLED_DISPLAY_WIDTH 128
   #define OLED_DISPLAY_HEIGHT 32
   #define OLED_MATRIX_SIZE (OLED_DISPLAY_HEIGHT / 8 * OLED_DISPLAY_WIDTH) // 512 (compile time mathed)
-  #define OLED_BLOCK_TYPE uint8_t // Type to use for segmenting the oled display for smart rendering, use unsigned types only
+  #define OLED_BLOCK_TYPE uint16_t // Type to use for segmenting the oled display for smart rendering, use unsigned types only
-  #define OLED_BLOCK_COUNT (sizeof(OLED_BLOCK_TYPE) * 8) // 8 (compile time mathed)
+  #define OLED_BLOCK_COUNT (sizeof(OLED_BLOCK_TYPE) * 8) // 16 (compile time mathed)
-  #define OLED_BLOCK_SIZE (OLED_MATRIX_SIZE / OLED_BLOCK_COUNT) // 128 (compile time mathed)
+  #define OLED_BLOCK_SIZE (OLED_MATRIX_SIZE / OLED_BLOCK_COUNT) // 32 (compile time mathed)
 
   // For 90 degree rotation, we map our internal matrix to oled matrix using fixed arrays
   // The OLED writes to it's memory horizontally, starting top left, but our memory starts bottom left in this mode
-  #define OLED_SOURCE_MAP { 0, 8, 16, 24, 32, 40, 48, 56 }
+  #define OLED_SOURCE_MAP { 0, 8, 16, 24 }
-  #define OLED_TARGET_MAP { 48, 32, 16, 0, 56, 40, 24, 8 }
+  #define OLED_TARGET_MAP { 24, 16, 8, 0 }
+  // If OLED_BLOCK_TYPE is uint8_t, these tables would look like:
+  // #define OLED_SOURCE_MAP { 0, 8, 16, 24, 32, 40, 48, 56 }
+  // #define OLED_TARGET_MAP { 48, 32, 16, 0, 56, 40, 24, 8 }
 #endif // defined(OLED_DISPLAY_CUSTOM)
 
 // Address to use for tthe i2d oled communication
@@ -79,19 +85,22 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
   #define OLED_FONT_HEIGHT 8
 #endif
 
-#define OLED_ROTATION_0 0x00
+// OLED Rotation enum values are flags
-#define OLED_ROTATION_90 0x01
+typedef enum {
-#define OLED_ROTATION_180 0x02
+    OLED_ROTATION_0   = 0,
-#define OLED_ROTATION_270 0x03
+    OLED_ROTATION_90  = 1,
+    OLED_ROTATION_180 = 2,
+    OLED_ROTATION_270 = 3, // OLED_ROTATION_90 | OLED_ROTATION_180
+} oled_rotation_t;
 
 // Initialize the oled display, rotating the rendered output based on the define passed in.
 // Returns true if the OLED was initialized successfully
-bool oled_init(uint8_t rotation);
+bool oled_init(oled_rotation_t rotation);
 
 // Called at the start of oled_init, weak function overridable by the user
 // rotation - the value passed into oled_init
-// Return new uint8_t if you want to override default rotation
+// Return new oled_rotation_t if you want to override default rotation
-uint8_t oled_init_user(uint8_t rotation);
+oled_rotation_t oled_init_user(oled_rotation_t rotation);
 
 // Clears the display buffer, resets cursor position to 0, and sets the buffer to dirty for rendering
 void oled_clear(void);

keyboards/sol/keymaps/brianweyer/keymap.c

@@ -181,7 +181,7 @@ void matrix_init_user(void) {
 // OLED Driver Logic
 #ifdef OLED_DRIVER_ENABLE
 
-uint8_t oled_init_user(uint8_t rotation) {
+oled_rotation_t oled_init_user(oled_rotation_t rotation) {
   if (!has_usb())
     return OLED_ROTATION_180;  // flip 180 for offhand
   return rotation;

keyboards/sol/keymaps/danielhklein/keymap.c

@@ -246,7 +246,7 @@ void matrix_init_user(void) {
 // OLED Driver Logic
 #ifdef OLED_DRIVER_ENABLE
 
-uint8_t oled_init_user(uint8_t rotation) {
+oled_rotation_t oled_init_user(oled_rotation_t rotation) {
   if (!has_usb())
     return OLED_ROTATION_180;  // flip 180 for offhand
   return rotation;

keyboards/sol/keymaps/default/keymap.c

@@ -254,7 +254,7 @@ void matrix_init_user(void) {
 // OLED Driver Logic
 #ifdef OLED_DRIVER_ENABLE
 
-uint8_t oled_init_user(uint8_t rotation) {
+oled_rotation_t oled_init_user(oled_rotation_t rotation) {
   if (!has_usb())
     return OLED_ROTATION_180;  // flip 180 for offhand
   return rotation;

keyboards/zen/rev2/config.h

@@ -66,19 +66,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 /* ws2812 RGB LED */
 #define RGBLED_NUM 34    // Number of LEDs
 
-// If using 90 Degree rotation, increase block cout
-#ifdef OLED_ROTATE90
-  #define OLED_DISPLAY_CUSTOM
-  #define OLED_DISPLAY_WIDTH 128
-  #define OLED_DISPLAY_HEIGHT 32
-  #define OLED_MATRIX_SIZE (OLED_DISPLAY_HEIGHT / 8 * OLED_DISPLAY_WIDTH) // 512 (compile time mathed)
-  #define OLED_BLOCK_TYPE uint16_t // Type to use for segmenting the oled display for smart rendering, use unsigned types only
-  #define OLED_BLOCK_COUNT (sizeof(OLED_BLOCK_TYPE) * 8) // 8 (compile time mathed)
-  #define OLED_BLOCK_SIZE (OLED_MATRIX_SIZE / OLED_BLOCK_COUNT) // 32 (compile time mathed)
-  #define OLED_SOURCE_MAP { 0, 8, 16, 24 }
-  #define OLED_TARGET_MAP { 24, 16, 8, 0 }
-#endif
-
 /*
  * Feature disable options
  *  These options are also useful to firmware size reduction.

keyboards/zen/rev2/rev2.c

@@ -47,11 +47,11 @@ void render_status(void) {
   oled_write_P(led_usb_state & (1<<USB_LED_SCROLL_LOCK) ? PSTR("SCRLK") : PSTR("     "), false); // Line 16
 }
 
-#ifdef OLED_ROTATE90
+oled_rotation_t oled_init_user(oled_rotation_t rotation) {
-bool oled_init_user(bool flip180) {
+  if (is_keyboard_master())
-  return true;
+    return OLED_ROTATION_90;  // flips the display 90 degrees if mainhand
+  return rotation;
 }
-#endif
 
 __attribute__((weak))
 void oled_task_user(void) {

keyboards/zen/rev2/rules.mk

@@ -1,14 +1,9 @@
 ENCODER_ENABLE = yes
 
 OLED_DRIVER_ENABLE = no
-OLED_ROTATE90 = yes
 
-# Setup so that OLED and 90 degree rotation can be turned on/off easily
+# Setup so that OLED can be turned on/off easily
-# with "OLED_DRIVER_ENABLE = yes" or "OLED_ROTATE90 = no" in user's rules.mk file
 ifeq ($(strip $(OLED_DRIVER_ENABLE)), yes)
   # Custom local font file
   OPT_DEFS += -DOLED_FONT_H=\"common/glcdfont.c\"
-  ifeq ($(strip $(OLED_DRIVER_ENABLE)), yes)
-    OPT_DEFS += -DOLED_ROTATE90
-  endif
 endif