keyboard/qmk-keychron-q3-colemak-dh
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Ryan Caltabiano 2019-04-16 18:36:55 -05:00 committed by skullydazed
parent 0a645225b9
commit dd3a813f87
9 changed files with 69 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
docs/feature_oled_driver.md
View File

@ -56,7 +56,7 @@ In split keyboards, it is very common to have two OLED displays that each render
```C++ ```C++
#ifdef OLED_DRIVER_ENABLE #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()) if (!is_keyboard_master())
return OLED_ROTATION_180; // flips the display 180 degrees if offhand return OLED_ROTATION_180; // flips the display 180 degrees if offhand
return rotation; return rotation;
@ -99,18 +99,28 @@ void oled_task_user(void) {
|`OLED_DISPLAY_WIDTH` |`128` |The width of the OLED display. | |`OLED_DISPLAY_WIDTH` |`128` |The width of the OLED display. |
|`OLED_DISPLAY_HEIGHT` |`32` |The height 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_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_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 ### 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. 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 ## OLED API
```C++ ```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 // 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 // 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 // Clears the display buffer, resets cursor position to 0, and sets the buffer to dirty for rendering
void oled_clear(void); 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 // Returns the maximum number of characters that will fit on a line
uint8_t oled_max_chars(void); 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); uint8_t oled_max_lines(void);
``` ```

7
drivers/oled/oled_driver.c
View File

@ -203,7 +203,7 @@ bool oled_init(uint8_t rotation) {
} }
__attribute__((weak)) __attribute__((weak))
uint8_t oled_init_user(uint8_t rotation) { oled_rotation_t oled_init_user(oled_rotation_t rotation) {
return rotation; return rotation;
} }
@ -384,7 +384,10 @@ void oled_write_char(const char data, bool invert) {
// Dirty check // Dirty check
if (memcmp(&oled_temp_buffer, oled_cursor, OLED_FONT_WIDTH)) { 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 // Finally move to the next char

43
drivers/oled/oled_driver.h
View File

@ -27,14 +27,17 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define OLED_DISPLAY_WIDTH 128 #define OLED_DISPLAY_WIDTH 128
#define OLED_DISPLAY_HEIGHT 64 #define OLED_DISPLAY_HEIGHT 64
#define OLED_MATRIX_SIZE (OLED_DISPLAY_HEIGHT / 8 * OLED_DISPLAY_WIDTH) // 1024 (compile time mathed) #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 // 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 // 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: // 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_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 } // #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_WIDTH 128
#define OLED_DISPLAY_HEIGHT 32 #define OLED_DISPLAY_HEIGHT 32
#define OLED_MATRIX_SIZE (OLED_DISPLAY_HEIGHT / 8 * OLED_DISPLAY_WIDTH) // 512 (compile time mathed) #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 // 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 // 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) #endif // defined(OLED_DISPLAY_CUSTOM)
// Address to use for tthe i2d oled communication // 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 #define OLED_FONT_HEIGHT 8
#endif #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. // Initialize the oled display, rotating the rendered output based on the define passed in.
// Returns true if the OLED was initialized successfully // 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 // Called at the start of oled_init, weak function overridable by the user
// rotation - the value passed into oled_init // 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 // Clears the display buffer, resets cursor position to 0, and sets the buffer to dirty for rendering
void oled_clear(void); void oled_clear(void);

2
keyboards/sol/keymaps/brianweyer/keymap.c
View File

@ -181,7 +181,7 @@ void matrix_init_user(void) {
// OLED Driver Logic // OLED Driver Logic
#ifdef OLED_DRIVER_ENABLE #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()) if (!has_usb())
return OLED_ROTATION_180; // flip 180 for offhand return OLED_ROTATION_180; // flip 180 for offhand
return rotation; return rotation;

2
keyboards/sol/keymaps/danielhklein/keymap.c
View File

@ -246,7 +246,7 @@ void matrix_init_user(void) {
// OLED Driver Logic // OLED Driver Logic
#ifdef OLED_DRIVER_ENABLE #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()) if (!has_usb())
return OLED_ROTATION_180; // flip 180 for offhand return OLED_ROTATION_180; // flip 180 for offhand
return rotation; return rotation;

2
keyboards/sol/keymaps/default/keymap.c
View File

@ -254,7 +254,7 @@ void matrix_init_user(void) {
// OLED Driver Logic // OLED Driver Logic
#ifdef OLED_DRIVER_ENABLE #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()) if (!has_usb())
return OLED_ROTATION_180; // flip 180 for offhand return OLED_ROTATION_180; // flip 180 for offhand
return rotation; return rotation;

13
keyboards/zen/rev2/config.h
View File

@ -66,19 +66,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* ws2812 RGB LED */ /* ws2812 RGB LED */
#define RGBLED_NUM 34 // Number of LEDs #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 * Feature disable options
* These options are also useful to firmware size reduction. * These options are also useful to firmware size reduction.

8
keyboards/zen/rev2/rev2.c
View File

@ -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 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)) __attribute__((weak))
void oled_task_user(void) { void oled_task_user(void) {

7
keyboards/zen/rev2/rules.mk
View File

@ -1,14 +1,9 @@
ENCODER_ENABLE = yes ENCODER_ENABLE = yes
OLED_DRIVER_ENABLE = no 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) ifeq ($(strip $(OLED_DRIVER_ENABLE)), yes)
# Custom local font file # Custom local font file
OPT_DEFS += -DOLED_FONT_H=\"common/glcdfont.c\" OPT_DEFS += -DOLED_FONT_H=\"common/glcdfont.c\"
ifeq ($(strip $(OLED_DRIVER_ENABLE)), yes)
OPT_DEFS += -DOLED_ROTATE90
endif
endif endif