Purge uGFX. (#14720)
* Purge uGFX. * Remove remnants of visualizer. * Remove remnants of uGFX.fix_template_bootmagic
Nick Brassel
4 years ago
committed by
GitHub
parent
bc1f5ef381
commit
b2a186cf92
@ -1,105 +0,0 @@ |
||||
/*
|
||||
Copyright 2016 Fred Sundvik <fsundvik@gmail.com> |
||||
|
||||
This program is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License as published by |
||||
the Free Software Foundation, either version 2 of the License, or |
||||
(at your option) any later version. |
||||
|
||||
This program is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
|
||||
#ifndef _GDISP_LLD_BOARD_H |
||||
#define _GDISP_LLD_BOARD_H |
||||
|
||||
static const I2CConfig i2ccfg = { |
||||
400000 // clock speed (Hz); 400kHz max for IS31
|
||||
}; |
||||
|
||||
static const uint8_t led_mask[] = { |
||||
0xFF, 0x00, /* C1-1 -> C1-16 */ |
||||
0xFF, 0x00, /* C2-1 -> C2-16 */ |
||||
0xFF, 0x00, /* C3-1 -> C3-16 */ |
||||
0xFF, 0x00, /* C4-1 -> C4-16 */ |
||||
0x3F, 0x00, /* C5-1 -> C5-16 */ |
||||
0x00, 0x00, /* C6-1 -> C6-16 */ |
||||
0x00, 0x00, /* C7-1 -> C7-16 */ |
||||
0x00, 0x00, /* C8-1 -> C8-16 */ |
||||
0x00, 0x00, /* C9-1 -> C9-16 */ |
||||
}; |
||||
|
||||
// The address of the LED
|
||||
#define LA(c, r) (c + r * 16) |
||||
// Need to be an address that is not mapped, but inside the range of the controller matrix
|
||||
#define NA LA(8, 8) |
||||
|
||||
// The numbers in the comments are the led numbers DXX on the PCB
|
||||
// The mapping is taken from the schematic of left hand side
|
||||
static const uint8_t led_mapping[GDISP_SCREEN_HEIGHT][GDISP_SCREEN_WIDTH] = { |
||||
// 45 44 43 42 41 40 39
|
||||
{LA(1, 1), LA(1, 0), LA(0, 4), LA(0, 3), LA(0, 2), LA(0, 1), LA(0, 0)}, |
||||
// 52 51 50 49 48 47 46
|
||||
{LA(2, 3), LA(2, 2), LA(2, 1), LA(2, 0), LA(1, 4), LA(1, 3), LA(1, 2)}, |
||||
// 58 57 56 55 54 53 N/A
|
||||
{LA(3, 4), LA(3, 3), LA(3, 2), LA(3, 1), LA(3, 0), LA(2, 4), NA}, |
||||
// 67 66 65 64 63 62 61
|
||||
{LA(5, 3), LA(5, 2), LA(5, 1), LA(5, 0), LA(4, 4), LA(4, 3), LA(4, 2)}, |
||||
// 76 75 74 73 72 60 59
|
||||
{LA(7, 3), LA(7, 2), LA(7, 1), LA(7, 0), LA(6, 3), LA(4, 1), LA(4, 0)}, |
||||
// N/A N/A N/A N/A N/A N/A 68
|
||||
{NA, NA, NA, NA, NA, NA, LA(5, 4)}, |
||||
// N/A N/A N/A N/A 71 70 69
|
||||
{NA, NA, NA, NA, LA(6, 2), LA(6, 1), LA(6, 0)}, |
||||
}; |
||||
|
||||
#define IS31_ADDR_DEFAULT 0x74 // AD connected to GND
|
||||
#define IS31_TIMEOUT 5000 |
||||
|
||||
static GFXINLINE void init_board(GDisplay* g) { |
||||
(void)g; |
||||
/* I2C pins */ |
||||
palSetPadMode(GPIOB, 0, PAL_MODE_ALTERNATIVE_2); // PTB0/I2C0/SCL
|
||||
palSetPadMode(GPIOB, 1, PAL_MODE_ALTERNATIVE_2); // PTB1/I2C0/SDA
|
||||
palSetPadMode(GPIOB, 16, PAL_MODE_OUTPUT_PUSHPULL); |
||||
palClearPad(GPIOB, 16); |
||||
/* start I2C */ |
||||
i2cStart(&I2CD1, &i2ccfg); |
||||
// try high drive (from kiibohd)
|
||||
I2CD1.i2c->C2 |= I2Cx_C2_HDRS; |
||||
// try glitch fixing (from kiibohd)
|
||||
I2CD1.i2c->FLT = 4; |
||||
} |
||||
|
||||
static GFXINLINE void post_init_board(GDisplay* g) { (void)g; } |
||||
|
||||
static GFXINLINE const uint8_t* get_led_mask(GDisplay* g) { |
||||
(void)g; |
||||
return led_mask; |
||||
} |
||||
|
||||
static GFXINLINE uint8_t get_led_address(GDisplay* g, uint16_t x, uint16_t y) { |
||||
(void)g; |
||||
return led_mapping[y][x]; |
||||
} |
||||
|
||||
static GFXINLINE void set_hardware_shutdown(GDisplay* g, bool shutdown) { |
||||
(void)g; |
||||
if (!shutdown) { |
||||
palSetPad(GPIOB, 16); |
||||
} else { |
||||
palClearPad(GPIOB, 16); |
||||
} |
||||
} |
||||
|
||||
static GFXINLINE void write_data(GDisplay* g, uint8_t* data, uint16_t length) { |
||||
(void)g; |
||||
i2cMasterTransmitTimeout(&I2CD1, IS31_ADDR_DEFAULT, data, length, 0, 0, US2ST(IS31_TIMEOUT)); |
||||
} |
||||
|
||||
#endif /* _GDISP_LLD_BOARD_H */ |
||||
@ -1,3 +0,0 @@ |
||||
GFXINC += drivers/ugfx/gdisp/is31fl3731c
|
||||
GFXSRC += drivers/ugfx/gdisp/is31fl3731c/gdisp_is31fl3731c.c
|
||||
GDISP_DRIVER_LIST += GDISPVMT_IS31FL3731C_QMK
|
||||
@ -1,302 +0,0 @@ |
||||
/*
|
||||
Copyright 2016 Fred Sundvik <fsundvik@gmail.com> |
||||
|
||||
This program is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License as published by |
||||
the Free Software Foundation, either version 2 of the License, or |
||||
(at your option) any later version. |
||||
|
||||
This program is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
|
||||
#include "gfx.h" |
||||
|
||||
#if GFX_USE_GDISP |
||||
|
||||
# define GDISP_DRIVER_VMT GDISPVMT_IS31FL3731C_QMK |
||||
# define GDISP_SCREEN_HEIGHT LED_HEIGHT |
||||
# define GDISP_SCREEN_WIDTH LED_WIDTH |
||||
|
||||
# include "gdisp_lld_config.h" |
||||
# include "src/gdisp/gdisp_driver.h" |
||||
|
||||
# include "board_is31fl3731c.h" |
||||
|
||||
// Can't include led_tables from here
|
||||
extern const uint8_t CIE1931_CURVE[]; |
||||
|
||||
/*===========================================================================*/ |
||||
/* Driver local definitions. */ |
||||
/*===========================================================================*/ |
||||
|
||||
# ifndef GDISP_INITIAL_CONTRAST |
||||
# define GDISP_INITIAL_CONTRAST 0 |
||||
# endif |
||||
# ifndef GDISP_INITIAL_BACKLIGHT |
||||
# define GDISP_INITIAL_BACKLIGHT 0 |
||||
# endif |
||||
|
||||
# define GDISP_FLG_NEEDFLUSH (GDISP_FLG_DRIVER << 0) |
||||
|
||||
# define IS31_ADDR_DEFAULT 0x74 |
||||
|
||||
# define IS31_REG_CONFIG 0x00 |
||||
// bits in reg
|
||||
# define IS31_REG_CONFIG_PICTUREMODE 0x00 |
||||
# define IS31_REG_CONFIG_AUTOPLAYMODE 0x08 |
||||
# define IS31_REG_CONFIG_AUDIOPLAYMODE 0x18 |
||||
// D2:D0 bits are starting frame for autoplay mode
|
||||
|
||||
# define IS31_REG_PICTDISP 0x01 // D2:D0 frame select for picture mode
|
||||
|
||||
# define IS31_REG_AUTOPLAYCTRL1 0x02 |
||||
// D6:D4 number of loops (000=infty)
|
||||
// D2:D0 number of frames to be used
|
||||
|
||||
# define IS31_REG_AUTOPLAYCTRL2 0x03 // D5:D0 delay time (*11ms)
|
||||
|
||||
# define IS31_REG_DISPLAYOPT 0x05 |
||||
# define IS31_REG_DISPLAYOPT_INTENSITY_SAME 0x20 // same intensity for all frames
|
||||
# define IS31_REG_DISPLAYOPT_BLINK_ENABLE 0x8 |
||||
// D2:D0 bits blink period time (*0.27s)
|
||||
|
||||
# define IS31_REG_AUDIOSYNC 0x06 |
||||
# define IS31_REG_AUDIOSYNC_ENABLE 0x1 |
||||
|
||||
# define IS31_REG_FRAMESTATE 0x07 |
||||
|
||||
# define IS31_REG_BREATHCTRL1 0x08 |
||||
// D6:D4 fade out time (26ms*2^i)
|
||||
// D2:D0 fade in time (26ms*2^i)
|
||||
|
||||
# define IS31_REG_BREATHCTRL2 0x09 |
||||
# define IS31_REG_BREATHCTRL2_ENABLE 0x10 |
||||
// D2:D0 extinguish time (3.5ms*2^i)
|
||||
|
||||
# define IS31_REG_SHUTDOWN 0x0A |
||||
# define IS31_REG_SHUTDOWN_OFF 0x0 |
||||
# define IS31_REG_SHUTDOWN_ON 0x1 |
||||
|
||||
# define IS31_REG_AGCCTRL 0x0B |
||||
# define IS31_REG_ADCRATE 0x0C |
||||
|
||||
# define IS31_COMMANDREGISTER 0xFD |
||||
# define IS31_FUNCTIONREG 0x0B // helpfully called 'page nine'
|
||||
# define IS31_FUNCTIONREG_SIZE 0xD |
||||
|
||||
# define IS31_FRAME_SIZE 0xB4 |
||||
|
||||
# define IS31_PWM_REG 0x24 |
||||
# define IS31_PWM_SIZE 0x90 |
||||
|
||||
# define IS31_LED_MASK_SIZE 0x12 |
||||
|
||||
# define IS31 |
||||
|
||||
/*===========================================================================*/ |
||||
/* Driver local functions. */ |
||||
/*===========================================================================*/ |
||||
|
||||
typedef struct { |
||||
uint8_t write_buffer_offset; |
||||
uint8_t write_buffer[IS31_FRAME_SIZE]; |
||||
uint8_t frame_buffer[GDISP_SCREEN_HEIGHT * GDISP_SCREEN_WIDTH]; |
||||
uint8_t page; |
||||
} __attribute__((__packed__)) PrivData; |
||||
|
||||
// Some common routines and macros
|
||||
# define PRIV(g) ((PrivData *)g->priv) |
||||
|
||||
/*===========================================================================*/ |
||||
/* Driver exported functions. */ |
||||
/*===========================================================================*/ |
||||
|
||||
static GFXINLINE void write_page(GDisplay *g, uint8_t page) { |
||||
uint8_t tx[2] __attribute__((aligned(2))); |
||||
tx[0] = IS31_COMMANDREGISTER; |
||||
tx[1] = page; |
||||
write_data(g, tx, 2); |
||||
} |
||||
|
||||
static GFXINLINE void write_register(GDisplay *g, uint8_t page, uint8_t reg, uint8_t data) { |
||||
uint8_t tx[2] __attribute__((aligned(2))); |
||||
tx[0] = reg; |
||||
tx[1] = data; |
||||
write_page(g, page); |
||||
write_data(g, tx, 2); |
||||
} |
||||
|
||||
static GFXINLINE void write_ram(GDisplay *g, uint8_t page, uint16_t offset, uint16_t length) { |
||||
PRIV(g)->write_buffer_offset = offset; |
||||
write_page(g, page); |
||||
write_data(g, (uint8_t *)PRIV(g), length + 1); |
||||
} |
||||
|
||||
LLDSPEC bool_t gdisp_lld_init(GDisplay *g) { |
||||
// The private area is the display surface.
|
||||
g->priv = gfxAlloc(sizeof(PrivData)); |
||||
__builtin_memset(PRIV(g), 0, sizeof(PrivData)); |
||||
PRIV(g)->page = 0; |
||||
|
||||
// Initialise the board interface
|
||||
init_board(g); |
||||
gfxSleepMilliseconds(10); |
||||
|
||||
// zero function page, all registers (assuming full_page is all zeroes)
|
||||
write_ram(g, IS31_FUNCTIONREG, 0, IS31_FUNCTIONREG_SIZE); |
||||
set_hardware_shutdown(g, false); |
||||
gfxSleepMilliseconds(10); |
||||
// software shutdown
|
||||
write_register(g, IS31_FUNCTIONREG, IS31_REG_SHUTDOWN, IS31_REG_SHUTDOWN_OFF); |
||||
gfxSleepMilliseconds(10); |
||||
// zero function page, all registers
|
||||
write_ram(g, IS31_FUNCTIONREG, 0, IS31_FUNCTIONREG_SIZE); |
||||
gfxSleepMilliseconds(10); |
||||
|
||||
// zero all LED registers on all 8 pages, and enable the mask
|
||||
__builtin_memcpy(PRIV(g)->write_buffer, get_led_mask(g), IS31_LED_MASK_SIZE); |
||||
for (uint8_t i = 0; i < 8; i++) { |
||||
write_ram(g, i, 0, IS31_FRAME_SIZE); |
||||
gfxSleepMilliseconds(1); |
||||
} |
||||
|
||||
// software shutdown disable (i.e. turn stuff on)
|
||||
write_register(g, IS31_FUNCTIONREG, IS31_REG_SHUTDOWN, IS31_REG_SHUTDOWN_OFF); |
||||
gfxSleepMilliseconds(10); |
||||
|
||||
// Finish Init
|
||||
post_init_board(g); |
||||
|
||||
/* Initialise the GDISP structure */ |
||||
g->g.Width = GDISP_SCREEN_WIDTH; |
||||
g->g.Height = GDISP_SCREEN_HEIGHT; |
||||
g->g.Orientation = GDISP_ROTATE_0; |
||||
g->g.Powermode = powerOff; |
||||
g->g.Backlight = GDISP_INITIAL_BACKLIGHT; |
||||
g->g.Contrast = GDISP_INITIAL_CONTRAST; |
||||
return TRUE; |
||||
} |
||||
|
||||
# if GDISP_HARDWARE_FLUSH |
||||
LLDSPEC void gdisp_lld_flush(GDisplay *g) { |
||||
// Don't flush if we don't need it.
|
||||
if (!(g->flags & GDISP_FLG_NEEDFLUSH)) return; |
||||
|
||||
PRIV(g)->page++; |
||||
PRIV(g)->page %= 2; |
||||
// TODO: some smarter algorithm for this
|
||||
// We should run only one physical page at a time
|
||||
// This way we don't need to send so much data, and
|
||||
// we could use slightly less memory
|
||||
uint8_t *src = PRIV(g)->frame_buffer; |
||||
for (int y = 0; y < GDISP_SCREEN_HEIGHT; y++) { |
||||
for (int x = 0; x < GDISP_SCREEN_WIDTH; x++) { |
||||
uint8_t val = (uint16_t)*src * g->g.Backlight / 100; |
||||
PRIV(g)->write_buffer[get_led_address(g, x, y)] = CIE1931_CURVE[val]; |
||||
++src; |
||||
} |
||||
} |
||||
write_ram(g, PRIV(g)->page, IS31_PWM_REG, IS31_PWM_SIZE); |
||||
gfxSleepMilliseconds(1); |
||||
write_register(g, IS31_FUNCTIONREG, IS31_REG_PICTDISP, PRIV(g)->page); |
||||
|
||||
g->flags &= ~GDISP_FLG_NEEDFLUSH; |
||||
} |
||||
# endif |
||||
|
||||
# if GDISP_HARDWARE_DRAWPIXEL |
||||
LLDSPEC void gdisp_lld_draw_pixel(GDisplay *g) { |
||||
coord_t x, y; |
||||
|
||||
switch (g->g.Orientation) { |
||||
default: |
||||
case GDISP_ROTATE_0: |
||||
x = g->p.x; |
||||
y = g->p.y; |
||||
break; |
||||
case GDISP_ROTATE_180: |
||||
x = GDISP_SCREEN_WIDTH - 1 - g->p.x; |
||||
y = g->p.y; |
||||
break; |
||||
} |
||||
PRIV(g)->frame_buffer[y * GDISP_SCREEN_WIDTH + x] = gdispColor2Native(g->p.color); |
||||
g->flags |= GDISP_FLG_NEEDFLUSH; |
||||
} |
||||
# endif |
||||
|
||||
# if GDISP_HARDWARE_PIXELREAD |
||||
LLDSPEC color_t gdisp_lld_get_pixel_color(GDisplay *g) { |
||||
coord_t x, y; |
||||
|
||||
switch (g->g.Orientation) { |
||||
default: |
||||
case GDISP_ROTATE_0: |
||||
x = g->p.x; |
||||
y = g->p.y; |
||||
break; |
||||
case GDISP_ROTATE_180: |
||||
x = GDISP_SCREEN_WIDTH - 1 - g->p.x; |
||||
y = g->p.y; |
||||
break; |
||||
} |
||||
return gdispNative2Color(PRIV(g)->frame_buffer[y * GDISP_SCREEN_WIDTH + x]); |
||||
} |
||||
# endif |
||||
|
||||
# if GDISP_NEED_CONTROL && GDISP_HARDWARE_CONTROL |
||||
LLDSPEC void gdisp_lld_control(GDisplay *g) { |
||||
switch (g->p.x) { |
||||
case GDISP_CONTROL_POWER: |
||||
if (g->g.Powermode == (powermode_t)g->p.ptr) return; |
||||
switch ((powermode_t)g->p.ptr) { |
||||
case powerOff: |
||||
case powerSleep: |
||||
case powerDeepSleep: |
||||
write_register(g, IS31_FUNCTIONREG, IS31_REG_SHUTDOWN, IS31_REG_SHUTDOWN_OFF); |
||||
break; |
||||
case powerOn: |
||||
write_register(g, IS31_FUNCTIONREG, IS31_REG_SHUTDOWN, IS31_REG_SHUTDOWN_ON); |
||||
break; |
||||
default: |
||||
return; |
||||
} |
||||
g->g.Powermode = (powermode_t)g->p.ptr; |
||||
return; |
||||
|
||||
case GDISP_CONTROL_ORIENTATION: |
||||
if (g->g.Orientation == (orientation_t)g->p.ptr) return; |
||||
switch ((orientation_t)g->p.ptr) { |
||||
/* Rotation is handled by the drawing routines */ |
||||
case GDISP_ROTATE_0: |
||||
case GDISP_ROTATE_180: |
||||
g->g.Height = GDISP_SCREEN_HEIGHT; |
||||
g->g.Width = GDISP_SCREEN_WIDTH; |
||||
break; |
||||
case GDISP_ROTATE_90: |
||||
case GDISP_ROTATE_270: |
||||
g->g.Height = GDISP_SCREEN_WIDTH; |
||||
g->g.Width = GDISP_SCREEN_HEIGHT; |
||||
break; |
||||
default: |
||||
return; |
||||
} |
||||
g->g.Orientation = (orientation_t)g->p.ptr; |
||||
return; |
||||
|
||||
case GDISP_CONTROL_BACKLIGHT: |
||||
if (g->g.Backlight == (unsigned)g->p.ptr) return; |
||||
unsigned val = (unsigned)g->p.ptr; |
||||
g->g.Backlight = val > 100 ? 100 : val; |
||||
g->flags |= GDISP_FLG_NEEDFLUSH; |
||||
return; |
||||
} |
||||
} |
||||
# endif // GDISP_NEED_CONTROL
|
||||
|
||||
#endif // GFX_USE_GDISP
|
||||
@ -1,36 +0,0 @@ |
||||
/*
|
||||
Copyright 2016 Fred Sundvik <fsundvik@gmail.com> |
||||
|
||||
This program is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License as published by |
||||
the Free Software Foundation, either version 2 of the License, or |
||||
(at your option) any later version. |
||||
|
||||
This program is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
|
||||
#ifndef _GDISP_LLD_CONFIG_H |
||||
#define _GDISP_LLD_CONFIG_H |
||||
|
||||
#if GFX_USE_GDISP |
||||
|
||||
/*===========================================================================*/ |
||||
/* Driver hardware support. */ |
||||
/*===========================================================================*/ |
||||
|
||||
# define GDISP_HARDWARE_FLUSH GFXON // This controller requires flushing
|
||||
# define GDISP_HARDWARE_DRAWPIXEL GFXON |
||||
# define GDISP_HARDWARE_PIXELREAD GFXON |
||||
# define GDISP_HARDWARE_CONTROL GFXON |
||||
|
||||
# define GDISP_LLD_PIXELFORMAT GDISP_PIXELFORMAT_GRAY256 |
||||
|
||||
#endif /* GFX_USE_GDISP */ |
||||
|
||||
#endif /* _GDISP_LLD_CONFIG_H */ |
||||
@ -1,96 +0,0 @@ |
||||
/*
|
||||
* This file is subject to the terms of the GFX License. If a copy of |
||||
* the license was not distributed with this file, you can obtain one at: |
||||
* |
||||
* http://ugfx.org/license.html
|
||||
*/ |
||||
|
||||
#ifndef _GDISP_LLD_BOARD_H |
||||
#define _GDISP_LLD_BOARD_H |
||||
|
||||
#include "quantum.h" |
||||
|
||||
#define ST7565_LCD_BIAS ST7565_LCD_BIAS_7 |
||||
#define ST7565_COM_SCAN ST7565_COM_SCAN_DEC |
||||
#define ST7565_PAGE_ORDER 0, 1, 2, 3 |
||||
/*
|
||||
* Custom page order for several LCD boards, e.g. HEM12864-99 |
||||
* #define ST7565_PAGE_ORDER 4,5,6,7,0,1,2,3 |
||||
*/ |
||||
|
||||
#define ST7565_A0_PIN C7 |
||||
#define ST7565_RST_PIN C8 |
||||
#define ST7565_MOSI_PIN C6 |
||||
#define ST7565_SCLK_PIN C5 |
||||
#define ST7565_SS_PIN C4 |
||||
|
||||
// DSPI Clock and Transfer Attributes
|
||||
// Frame Size: 8 bits
|
||||
// MSB First
|
||||
// CLK Low by default
|
||||
static const SPIConfig spi1config = { |
||||
// Operation complete callback or @p NULL.
|
||||
.end_cb = NULL, |
||||
// The chip select line port - when not using pcs.
|
||||
.ssport = PAL_PORT(ST7565_SS_PIN), |
||||
// brief The chip select line pad number - when not using pcs.
|
||||
.sspad = PAL_PAD(ST7565_SS_PIN), |
||||
// SPI initialization data.
|
||||
.tar0 = SPIx_CTARn_FMSZ(7) // Frame size = 8 bytes
|
||||
| SPIx_CTARn_ASC(1) // After SCK Delay Scaler (min 50 ns) = 55.56ns
|
||||
| SPIx_CTARn_DT(0) // Delay After Transfer Scaler (no minimum)= 27.78ns
|
||||
| SPIx_CTARn_CSSCK(0) // PCS to SCK Delay Scaler (min 20 ns) = 27.78ns
|
||||
| SPIx_CTARn_PBR(0) // Baud Rate Prescaler = 2
|
||||
| SPIx_CTARn_BR(0) // Baud rate (min 50ns) = 55.56ns
|
||||
}; |
||||
|
||||
static GFXINLINE void acquire_bus(GDisplay *g) { |
||||
(void)g; |
||||
// Only the LCD is using the SPI bus, so no need to acquire
|
||||
// spiAcquireBus(&SPID1);
|
||||
spiSelect(&SPID1); |
||||
} |
||||
|
||||
static GFXINLINE void release_bus(GDisplay *g) { |
||||
(void)g; |
||||
// Only the LCD is using the SPI bus, so no need to release
|
||||
// spiReleaseBus(&SPID1);
|
||||
spiUnselect(&SPID1); |
||||
} |
||||
|
||||
static GFXINLINE void init_board(GDisplay *g) { |
||||
(void)g; |
||||
setPinOutput(ST7565_A0_PIN); |
||||
writePinHigh(ST7565_A0_PIN); |
||||
setPinOutput(ST7565_RST_PIN); |
||||
writePinHigh(ST7565_RST_PIN); |
||||
setPinOutput(ST7565_SS_PIN); |
||||
|
||||
palSetPadMode(PAL_PORT(ST7565_MOSI_PIN), PAL_PAD(ST7565_MOSI_PIN), PAL_MODE_ALTERNATIVE_2); |
||||
palSetPadMode(PAL_PORT(ST7565_SCLK_PIN), PAL_PAD(ST7565_SCLK_PIN), PAL_MODE_ALTERNATIVE_2); |
||||
|
||||
spiInit(); |
||||
spiStart(&SPID1, &spi1config); |
||||
release_bus(g); |
||||
} |
||||
|
||||
static GFXINLINE void post_init_board(GDisplay *g) { (void)g; } |
||||
|
||||
static GFXINLINE void setpin_reset(GDisplay *g, bool_t state) { |
||||
(void)g; |
||||
writePin(ST7565_RST_PIN, !state); |
||||
} |
||||
|
||||
static GFXINLINE void write_cmd(GDisplay *g, gU8 cmd) { |
||||
(void)g; |
||||
writePinLow(ST7565_A0_PIN); |
||||
spiSend(&SPID1, 1, &cmd); |
||||
} |
||||
|
||||
static GFXINLINE void write_data(GDisplay *g, gU8 *data, gU16 length) { |
||||
(void)g; |
||||
writePinHigh(ST7565_A0_PIN); |
||||
spiSend(&SPID1, length, data); |
||||
} |
||||
|
||||
#endif /* _GDISP_LLD_BOARD_H */ |
||||
@ -1,3 +0,0 @@ |
||||
GFXINC += drivers/ugfx/gdisp/st7565
|
||||
GFXSRC += drivers/ugfx/gdisp/st7565/gdisp_lld_ST7565.c
|
||||
GDISP_DRIVER_LIST += GDISPVMT_ST7565_QMK
|
||||
@ -1,314 +0,0 @@ |
||||
/*
|
||||
* This file is subject to the terms of the GFX License. If a copy of |
||||
* the license was not distributed with this file, you can obtain one at: |
||||
* |
||||
* http://ugfx.org/license.html
|
||||
*/ |
||||
|
||||
#include "gfx.h" |
||||
|
||||
#if GFX_USE_GDISP |
||||
|
||||
# define GDISP_DRIVER_VMT GDISPVMT_ST7565_QMK |
||||
# include "gdisp_lld_config.h" |
||||
# include "src/gdisp/gdisp_driver.h" |
||||
|
||||
# include "board_st7565.h" |
||||
|
||||
/*===========================================================================*/ |
||||
/* Driver local definitions. */ |
||||
/*===========================================================================*/ |
||||
|
||||
# ifndef GDISP_SCREEN_HEIGHT |
||||
# define GDISP_SCREEN_HEIGHT LCD_HEIGHT |
||||
# endif |
||||
# ifndef GDISP_SCREEN_WIDTH |
||||
# define GDISP_SCREEN_WIDTH LCD_WIDTH |
||||
# endif |
||||
# ifndef GDISP_INITIAL_CONTRAST |
||||
# define GDISP_INITIAL_CONTRAST 35 |
||||
# endif |
||||
# ifndef GDISP_INITIAL_BACKLIGHT |
||||
# define GDISP_INITIAL_BACKLIGHT 100 |
||||
# endif |
||||
|
||||
# define GDISP_FLG_NEEDFLUSH (GDISP_FLG_DRIVER << 0) |
||||
|
||||
# include "st7565.h" |
||||
|
||||
/*===========================================================================*/ |
||||
/* Driver config defaults for backward compatibility. */ |
||||
/*===========================================================================*/ |
||||
# ifndef ST7565_LCD_BIAS |
||||
# define ST7565_LCD_BIAS ST7565_LCD_BIAS_7 |
||||
# endif |
||||
# ifndef ST7565_ADC |
||||
# define ST7565_ADC ST7565_ADC_NORMAL |
||||
# endif |
||||
# ifndef ST7565_COM_SCAN |
||||
# define ST7565_COM_SCAN ST7565_COM_SCAN_INC |
||||
# endif |
||||
# ifndef ST7565_PAGE_ORDER |
||||
# define ST7565_PAGE_ORDER 0, 1, 2, 3, 4, 5, 6, 7 |
||||
# endif |
||||
|
||||
/*===========================================================================*/ |
||||
/* Driver local functions. */ |
||||
/*===========================================================================*/ |
||||
|
||||
// Some common routines and macros
|
||||
# define RAM(g) ((gU8 *)g->priv) |
||||
# define write_cmd2(g, cmd1, cmd2) \ |
||||
{ \
|
||||
write_cmd(g, cmd1); \
|
||||
write_cmd(g, cmd2); \
|
||||
} |
||||
# define write_cmd3(g, cmd1, cmd2, cmd3) \ |
||||
{ \
|
||||
write_cmd(g, cmd1); \
|
||||
write_cmd(g, cmd2); \
|
||||
write_cmd(g, cmd3); \
|
||||
} |
||||
|
||||
// Some common routines and macros
|
||||
# define delay(us) gfxSleepMicroseconds(us) |
||||
# define delay_ms(ms) gfxSleepMilliseconds(ms) |
||||
|
||||
# define xyaddr(x, y) ((x) + ((y) >> 3) * GDISP_SCREEN_WIDTH) |
||||
# define xybit(y) (1 << ((y)&7)) |
||||
|
||||
/*===========================================================================*/ |
||||
/* Driver exported functions. */ |
||||
/*===========================================================================*/ |
||||
|
||||
/*
|
||||
* As this controller can't update on a pixel boundary we need to maintain the |
||||
* the entire display surface in memory so that we can do the necessary bit |
||||
* operations. Fortunately it is a small display in monochrome. |
||||
* 64 * 128 / 8 = 1024 bytes. |
||||
*/ |
||||
|
||||
LLDSPEC bool_t gdisp_lld_init(GDisplay *g) { |
||||
// The private area is the display surface.
|
||||
g->priv = gfxAlloc(GDISP_SCREEN_HEIGHT * GDISP_SCREEN_WIDTH / 8); |
||||
if (!g->priv) { |
||||
return gFalse; |
||||
} |
||||
|
||||
// Initialise the board interface
|
||||
init_board(g); |
||||
|
||||
// Hardware reset
|
||||
setpin_reset(g, TRUE); |
||||
gfxSleepMilliseconds(20); |
||||
setpin_reset(g, FALSE); |
||||
gfxSleepMilliseconds(20); |
||||
acquire_bus(g); |
||||
|
||||
write_cmd(g, ST7565_LCD_BIAS); |
||||
write_cmd(g, ST7565_ADC); |
||||
write_cmd(g, ST7565_COM_SCAN); |
||||
|
||||
write_cmd(g, ST7565_START_LINE | 0); |
||||
|
||||
write_cmd2(g, ST7565_CONTRAST, GDISP_INITIAL_CONTRAST * 64 / 101); |
||||
write_cmd(g, ST7565_RESISTOR_RATIO | 0x1); |
||||
|
||||
// turn on voltage converter (VC=1, VR=0, VF=0)
|
||||
write_cmd(g, ST7565_POWER_CONTROL | 0x04); |
||||
delay_ms(50); |
||||
|
||||
// turn on voltage regulator (VC=1, VR=1, VF=0)
|
||||
write_cmd(g, ST7565_POWER_CONTROL | 0x06); |
||||
delay_ms(50); |
||||
|
||||
// turn on voltage follower (VC=1, VR=1, VF=1)
|
||||
write_cmd(g, ST7565_POWER_CONTROL | 0x07); |
||||
delay_ms(50); |
||||
|
||||
write_cmd(g, ST7565_DISPLAY_ON); |
||||
write_cmd(g, ST7565_ALLON_NORMAL); |
||||
write_cmd(g, ST7565_INVERT_DISPLAY); // Disable Inversion of display.
|
||||
|
||||
write_cmd(g, ST7565_RMW); |
||||
|
||||
// Finish Init
|
||||
post_init_board(g); |
||||
|
||||
// Release the bus
|
||||
release_bus(g); |
||||
|
||||
/* Initialise the GDISP structure */ |
||||
g->g.Width = GDISP_SCREEN_WIDTH; |
||||
g->g.Height = GDISP_SCREEN_HEIGHT; |
||||
g->g.Orientation = GDISP_ROTATE_0; |
||||
g->g.Powermode = powerOff; |
||||
g->g.Backlight = GDISP_INITIAL_BACKLIGHT; |
||||
g->g.Contrast = GDISP_INITIAL_CONTRAST; |
||||
return TRUE; |
||||
} |
||||
|
||||
# if GDISP_HARDWARE_FLUSH |
||||
LLDSPEC void gdisp_lld_flush(GDisplay *g) { |
||||
unsigned p; |
||||
|
||||
// Don't flush if we don't need it.
|
||||
if (!(g->flags & GDISP_FLG_NEEDFLUSH)) return; |
||||
|
||||
acquire_bus(g); |
||||
gU8 pagemap[] = {ST7565_PAGE_ORDER}; |
||||
for (p = 0; p < sizeof(pagemap); p++) { |
||||
write_cmd(g, ST7565_PAGE | pagemap[p]); |
||||
write_cmd(g, ST7565_COLUMN_MSB | 0); |
||||
write_cmd(g, ST7565_COLUMN_LSB | 0); |
||||
write_cmd(g, ST7565_RMW); |
||||
write_data(g, RAM(g) + (p * GDISP_SCREEN_WIDTH), GDISP_SCREEN_WIDTH); |
||||
} |
||||
release_bus(g); |
||||
|
||||
g->flags &= ~GDISP_FLG_NEEDFLUSH; |
||||
} |
||||
# endif |
||||
|
||||
# if GDISP_HARDWARE_DRAWPIXEL |
||||
LLDSPEC void gdisp_lld_draw_pixel(GDisplay *g) { |
||||
coord_t x, y; |
||||
|
||||
switch (g->g.Orientation) { |
||||
default: |
||||
case GDISP_ROTATE_0: |
||||
x = g->p.x; |
||||
y = g->p.y; |
||||
break; |
||||
case GDISP_ROTATE_90: |
||||
x = g->p.y; |
||||
y = GDISP_SCREEN_HEIGHT - 1 - g->p.x; |
||||
break; |
||||
case GDISP_ROTATE_180: |
||||
x = GDISP_SCREEN_WIDTH - 1 - g->p.x; |
||||
y = GDISP_SCREEN_HEIGHT - 1 - g->p.y; |
||||
break; |
||||
case GDISP_ROTATE_270: |
||||
x = GDISP_SCREEN_HEIGHT - 1 - g->p.y; |
||||
y = g->p.x; |
||||
break; |
||||
} |
||||
if (gdispColor2Native(g->p.color) != Black) |
||||
RAM(g)[xyaddr(x, y)] |= xybit(y); |
||||
else |
||||
RAM(g)[xyaddr(x, y)] &= ~xybit(y); |
||||
g->flags |= GDISP_FLG_NEEDFLUSH; |
||||
} |
||||
# endif |
||||
|
||||
# if GDISP_HARDWARE_PIXELREAD |
||||
LLDSPEC color_t gdisp_lld_get_pixel_color(GDisplay *g) { |
||||
coord_t x, y; |
||||
|
||||
switch (g->g.Orientation) { |
||||
default: |
||||
case GDISP_ROTATE_0: |
||||
x = g->p.x; |
||||
y = g->p.y; |
||||
break; |
||||
case GDISP_ROTATE_90: |
||||
x = g->p.y; |
||||
y = GDISP_SCREEN_HEIGHT - 1 - g->p.x; |
||||
break; |
||||
case GDISP_ROTATE_180: |
||||
x = GDISP_SCREEN_WIDTH - 1 - g->p.x; |
||||
y = GDISP_SCREEN_HEIGHT - 1 - g->p.y; |
||||
break; |
||||
case GDISP_ROTATE_270: |
||||
x = GDISP_SCREEN_HEIGHT - 1 - g->p.y; |
||||
y = g->p.x; |
||||
break; |
||||
} |
||||
return (RAM(g)[xyaddr(x, y)] & xybit(y)) ? White : Black; |
||||
} |
||||
# endif |
||||
|
||||
# if GDISP_HARDWARE_BITFILLS |
||||
LLDSPEC void gdisp_lld_blit_area(GDisplay *g) { |
||||
uint8_t *buffer = (uint8_t *)g->p.ptr; |
||||
int linelength = g->p.cx; |
||||
for (int i = 0; i < g->p.cy; i++) { |
||||
unsigned dstx = g->p.x; |
||||
unsigned dsty = g->p.y + i; |
||||
unsigned srcx = g->p.x1; |
||||
unsigned srcy = g->p.y1 + i; |
||||
unsigned srcbit = srcy * g->p.x2 + srcx; |
||||
for (int j = 0; j < linelength; j++) { |
||||
uint8_t src = buffer[srcbit / 8]; |
||||
uint8_t bit = 7 - (srcbit % 8); |
||||
uint8_t bitset = (src >> bit) & 1; |
||||
uint8_t *dst = &(RAM(g)[xyaddr(dstx, dsty)]); |
||||
if (bitset) { |
||||
*dst |= xybit(dsty); |
||||
} else { |
||||
*dst &= ~xybit(dsty); |
||||
} |
||||
dstx++; |
||||
srcbit++; |
||||
} |
||||
} |
||||
g->flags |= GDISP_FLG_NEEDFLUSH; |
||||
} |
||||
# endif |
||||
|
||||
# if GDISP_NEED_CONTROL && GDISP_HARDWARE_CONTROL |
||||
LLDSPEC void gdisp_lld_control(GDisplay *g) { |
||||
switch (g->p.x) { |
||||
case GDISP_CONTROL_POWER: |
||||
if (g->g.Powermode == (powermode_t)g->p.ptr) return; |
||||
switch ((powermode_t)g->p.ptr) { |
||||
case powerOff: |
||||
case powerSleep: |
||||
case powerDeepSleep: |
||||
acquire_bus(g); |
||||
write_cmd(g, ST7565_DISPLAY_OFF); |
||||
release_bus(g); |
||||
break; |
||||
case powerOn: |
||||
acquire_bus(g); |
||||
write_cmd(g, ST7565_DISPLAY_ON); |
||||
release_bus(g); |
||||
break; |
||||
default: |
||||
return; |
||||
} |
||||
g->g.Powermode = (powermode_t)g->p.ptr; |
||||
return; |
||||
|
||||
case GDISP_CONTROL_ORIENTATION: |
||||
if (g->g.Orientation == (orientation_t)g->p.ptr) return; |
||||
switch ((orientation_t)g->p.ptr) { |
||||
/* Rotation is handled by the drawing routines */ |
||||
case GDISP_ROTATE_0: |
||||
case GDISP_ROTATE_180: |
||||
g->g.Height = GDISP_SCREEN_HEIGHT; |
||||
g->g.Width = GDISP_SCREEN_WIDTH; |
||||
break; |
||||
case GDISP_ROTATE_90: |
||||
case GDISP_ROTATE_270: |
||||
g->g.Height = GDISP_SCREEN_WIDTH; |
||||
g->g.Width = GDISP_SCREEN_HEIGHT; |
||||
break; |
||||
default: |
||||
return; |
||||
} |
||||
g->g.Orientation = (orientation_t)g->p.ptr; |
||||
return; |
||||
|
||||
case GDISP_CONTROL_CONTRAST: |
||||
if ((unsigned)g->p.ptr > 100) g->p.ptr = (void *)100; |
||||
acquire_bus(g); |
||||
write_cmd2(g, ST7565_CONTRAST, ((((unsigned)g->p.ptr) << 6) / 101) & 0x3F); |
||||
release_bus(g); |
||||
g->g.Contrast = (unsigned)g->p.ptr; |
||||
return; |
||||
} |
||||
} |
||||
# endif // GDISP_NEED_CONTROL
|
||||
|
||||
#endif // GFX_USE_GDISP
|
||||
@ -1,27 +0,0 @@ |
||||
/*
|
||||
* This file is subject to the terms of the GFX License. If a copy of |
||||
* the license was not distributed with this file, you can obtain one at: |
||||
* |
||||
* http://ugfx.org/license.html
|
||||
*/ |
||||
|
||||
#ifndef _GDISP_LLD_CONFIG_H |
||||
#define _GDISP_LLD_CONFIG_H |
||||
|
||||
#if GFX_USE_GDISP |
||||
|
||||
/*===========================================================================*/ |
||||
/* Driver hardware support. */ |
||||
/*===========================================================================*/ |
||||
|
||||
# define GDISP_HARDWARE_FLUSH GFXON // This controller requires flushing
|
||||
# define GDISP_HARDWARE_DRAWPIXEL GFXON |
||||
# define GDISP_HARDWARE_PIXELREAD GFXON |
||||
# define GDISP_HARDWARE_CONTROL GFXON |
||||
# define GDISP_HARDWARE_BITFILLS GFXON |
||||
|
||||
# define GDISP_LLD_PIXELFORMAT GDISP_PIXELFORMAT_MONO |
||||
|
||||
#endif /* GFX_USE_GDISP */ |
||||
|
||||
#endif /* _GDISP_LLD_CONFIG_H */ |
||||
@ -1,39 +0,0 @@ |
||||
/*
|
||||
* This file is subject to the terms of the GFX License. If a copy of |
||||
* the license was not distributed with this file, you can obtain one at: |
||||
* |
||||
* http://ugfx.org/license.html
|
||||
*/ |
||||
|
||||
#ifndef _ST7565_H |
||||
#define _ST7565_H |
||||
|
||||
#define ST7565_CONTRAST 0x81 |
||||
#define ST7565_ALLON_NORMAL 0xA4 |
||||
#define ST7565_ALLON 0xA5 |
||||
#define ST7565_POSITIVE_DISPLAY 0xA6 |
||||
#define ST7565_INVERT_DISPLAY 0xA7 |
||||
#define ST7565_DISPLAY_OFF 0xAE |
||||
#define ST7565_DISPLAY_ON 0xAF |
||||
|
||||
#define ST7565_LCD_BIAS_7 0xA3 |
||||
#define ST7565_LCD_BIAS_9 0xA2 |
||||
|
||||
#define ST7565_ADC_NORMAL 0xA0 |
||||
#define ST7565_ADC_REVERSE 0xA1 |
||||
|
||||
#define ST7565_COM_SCAN_INC 0xC0 |
||||
#define ST7565_COM_SCAN_DEC 0xC8 |
||||
|
||||
#define ST7565_START_LINE 0x40 |
||||
#define ST7565_PAGE 0xB0 |
||||
#define ST7565_COLUMN_MSB 0x10 |
||||
#define ST7565_COLUMN_LSB 0x00 |
||||
#define ST7565_RMW 0xE0 |
||||
|
||||
#define ST7565_RESISTOR_RATIO 0x20 |
||||
#define ST7565_POWER_CONTROL 0x28 |
||||
|
||||
#define ST7565_RESET 0xE2 |
||||
|
||||
#endif /* _ST7565_H */ |
||||
@ -1,110 +0,0 @@ |
||||
/*
|
||||
Copyright 2016 Fred Sundvik <fsundvik@gmail.com> |
||||
|
||||
This program is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License as published by |
||||
the Free Software Foundation, either version 2 of the License, or |
||||
(at your option) any later version. |
||||
|
||||
This program is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
|
||||
#ifndef _GDISP_LLD_BOARD_H |
||||
#define _GDISP_LLD_BOARD_H |
||||
|
||||
static const I2CConfig i2ccfg = { |
||||
400000 // clock speed (Hz); 400kHz max for IS31
|
||||
}; |
||||
|
||||
static const uint8_t led_mask[] = { |
||||
0xFF, 0x00, /* C1-1 -> C1-16 */ |
||||
0xFF, 0x00, /* C2-1 -> C2-16 */ |
||||
0xFF, 0x00, /* C3-1 -> C3-16 */ |
||||
0xFF, 0x00, /* C4-1 -> C4-16 */ |
||||
0x3F, 0x00, /* C5-1 -> C5-16 */ |
||||
0x00, 0x00, /* C6-1 -> C6-16 */ |
||||
0x00, 0x00, /* C7-1 -> C7-16 */ |
||||
0x00, 0x00, /* C8-1 -> C8-16 */ |
||||
0x00, 0x00, /* C9-1 -> C9-16 */ |
||||
}; |
||||
|
||||
// The address of the LED
|
||||
#define LA(c, r) (c + r * 16 ) |
||||
// Need to be an address that is not mapped, but inside the range of the controller matrix
|
||||
#define NA LA(8, 8) |
||||
|
||||
// The numbers in the comments are the led numbers DXX on the PCB
|
||||
// The mapping is taken from the schematic of left hand side
|
||||
static const uint8_t led_mapping[GDISP_SCREEN_HEIGHT][GDISP_SCREEN_WIDTH] = { |
||||
// 45 44 43 42 41 40 39
|
||||
{ LA(1, 1), LA(1, 0), LA(0, 4), LA(0, 3), LA(0, 2), LA(0, 1), LA(0, 0)}, |
||||
// 52 51 50 49 48 47 46
|
||||
{ LA(2, 3), LA(2, 2), LA(2, 1), LA(2, 0), LA(1, 4), LA(1, 3), LA(1, 2) }, |
||||
// 58 57 56 55 54 53 N/A
|
||||
{ LA(3, 4), LA(3, 3), LA(3, 2), LA(3, 1), LA(3, 0), LA(2, 4), NA }, |
||||
// 67 66 65 64 63 62 61
|
||||
{ LA(5, 3), LA(5, 2), LA(5, 1), LA(5, 0), LA(4, 4), LA(4, 3), LA(4, 2) }, |
||||
// 76 75 74 73 72 60 59
|
||||
{ LA(7, 3), LA(7, 2), LA(7, 1), LA(7, 0), LA(6, 3), LA(4, 1), LA(4, 0) }, |
||||
// N/A N/A N/A N/A N/A N/A 68
|
||||
{ NA, NA, NA, NA, NA, NA, LA(5, 4) }, |
||||
// N/A N/A N/A N/A 71 70 69
|
||||
{ NA, NA, NA, NA, LA(6, 2), LA(6, 1), LA(6, 0) }, |
||||
}; |
||||
|
||||
|
||||
#define IS31_ADDR_DEFAULT 0x74 // AD connected to GND
|
||||
#define IS31_TIMEOUT 5000 |
||||
|
||||
static GFXINLINE void init_board(GDisplay *g) { |
||||
(void) g; |
||||
/* I2C pins */ |
||||
palSetPadMode(GPIOB, 0, PAL_MODE_ALTERNATIVE_2); // PTB0/I2C0/SCL
|
||||
palSetPadMode(GPIOB, 1, PAL_MODE_ALTERNATIVE_2); // PTB1/I2C0/SDA
|
||||
palSetPadMode(GPIOB, 16, PAL_MODE_OUTPUT_PUSHPULL); |
||||
palClearPad(GPIOB, 16); |
||||
/* start I2C */ |
||||
i2cStart(&I2CD1, &i2ccfg); |
||||
// try high drive (from kiibohd)
|
||||
I2CD1.i2c->C2 |= I2Cx_C2_HDRS; |
||||
// try glitch fixing (from kiibohd)
|
||||
I2CD1.i2c->FLT = 4; |
||||
} |
||||
|
||||
static GFXINLINE void post_init_board(GDisplay *g) { |
||||
(void) g; |
||||
} |
||||
|
||||
static GFXINLINE const uint8_t* get_led_mask(GDisplay* g) { |
||||
(void) g; |
||||
return led_mask; |
||||
} |
||||
|
||||
static GFXINLINE uint8_t get_led_address(GDisplay* g, uint16_t x, uint16_t y) |
||||
{ |
||||
(void) g; |
||||
return led_mapping[y][x]; |
||||
} |
||||
|
||||
static GFXINLINE void set_hardware_shutdown(GDisplay* g, bool shutdown) { |
||||
(void) g; |
||||
if(!shutdown) { |
||||
palSetPad(GPIOB, 16); |
||||
} |
||||
else { |
||||
palClearPad(GPIOB, 16); |
||||
} |
||||
} |
||||
|
||||
static GFXINLINE void write_data(GDisplay *g, uint8_t* data, uint16_t length) { |
||||
(void) g; |
||||
i2cMasterTransmitTimeout(&I2CD1, IS31_ADDR_DEFAULT, data, length, 0, 0, TIME_US2I(IS31_TIMEOUT)); |
||||
} |
||||
|
||||
#endif /* _GDISP_LLD_BOARD_H */ |
||||
@ -1,96 +0,0 @@ |
||||
/*
|
||||
* This file is subject to the terms of the GFX License. If a copy of |
||||
* the license was not distributed with this file, you can obtain one at: |
||||
* |
||||
* http://ugfx.org/license.html
|
||||
*/ |
||||
|
||||
#ifndef _GDISP_LLD_BOARD_H |
||||
#define _GDISP_LLD_BOARD_H |
||||
|
||||
#include "quantum.h" |
||||
|
||||
#define ST7565_LCD_BIAS ST7565_LCD_BIAS_7 |
||||
#define ST7565_COM_SCAN ST7565_COM_SCAN_DEC |
||||
#define ST7565_PAGE_ORDER 0, 1, 2, 3 |
||||
/*
|
||||
* Custom page order for several LCD boards, e.g. HEM12864-99 |
||||
* #define ST7565_PAGE_ORDER 4,5,6,7,0,1,2,3 |
||||
*/ |
||||
|
||||
#define ST7565_A0_PIN C7 |
||||
#define ST7565_RST_PIN C8 |
||||
#define ST7565_MOSI_PIN C6 |
||||
#define ST7565_SCLK_PIN C5 |
||||
#define ST7565_SS_PIN C4 |
||||
|
||||
// DSPI Clock and Transfer Attributes
|
||||
// Frame Size: 8 bits
|
||||
// MSB First
|
||||
// CLK Low by default
|
||||
static const SPIConfig spi1config = { |
||||
// Operation complete callback or @p NULL.
|
||||
.end_cb = NULL, |
||||
// The chip select line port - when not using pcs.
|
||||
.ssport = PAL_PORT(ST7565_SS_PIN), |
||||
// brief The chip select line pad number - when not using pcs.
|
||||
.sspad = PAL_PAD(ST7565_SS_PIN), |
||||
// SPI initialization data.
|
||||
.tar0 = SPIx_CTARn_FMSZ(7) // Frame size = 8 bytes
|
||||
| SPIx_CTARn_ASC(1) // After SCK Delay Scaler (min 50 ns) = 55.56ns
|
||||
| SPIx_CTARn_DT(0) // Delay After Transfer Scaler (no minimum)= 27.78ns
|
||||
| SPIx_CTARn_CSSCK(0) // PCS to SCK Delay Scaler (min 20 ns) = 27.78ns
|
||||
| SPIx_CTARn_PBR(0) // Baud Rate Prescaler = 2
|
||||
| SPIx_CTARn_BR(0) // Baud rate (min 50ns) = 55.56ns
|
||||
}; |
||||
|
||||
static GFXINLINE void acquire_bus(GDisplay *g) { |
||||
(void)g; |
||||
// Only the LCD is using the SPI bus, so no need to acquire
|
||||
// spiAcquireBus(&SPID1);
|
||||
spiSelect(&SPID1); |
||||
} |
||||
|
||||
static GFXINLINE void release_bus(GDisplay *g) { |
||||
(void)g; |
||||
// Only the LCD is using the SPI bus, so no need to release
|
||||
// spiReleaseBus(&SPID1);
|
||||
spiUnselect(&SPID1); |
||||
} |
||||
|
||||
static GFXINLINE void init_board(GDisplay *g) { |
||||
(void)g; |
||||
setPinOutput(ST7565_A0_PIN); |
||||
writePinHigh(ST7565_A0_PIN); |
||||
setPinOutput(ST7565_RST_PIN); |
||||
writePinHigh(ST7565_RST_PIN); |
||||
setPinOutput(ST7565_SS_PIN); |
||||
|
||||
palSetPadMode(PAL_PORT(ST7565_MOSI_PIN), PAL_PAD(ST7565_MOSI_PIN), PAL_MODE_ALTERNATIVE_2); |
||||
palSetPadMode(PAL_PORT(ST7565_SCLK_PIN), PAL_PAD(ST7565_SCLK_PIN), PAL_MODE_ALTERNATIVE_2); |
||||
|
||||
spiInit(); |
||||
spiStart(&SPID1, &spi1config); |
||||
release_bus(g); |
||||
} |
||||
|
||||
static GFXINLINE void post_init_board(GDisplay *g) { (void)g; } |
||||
|
||||
static GFXINLINE void setpin_reset(GDisplay *g, bool_t state) { |
||||
(void)g; |
||||
writePin(ST7565_RST_PIN, !state); |
||||
} |
||||
|
||||
static GFXINLINE void write_cmd(GDisplay *g, gU8 cmd) { |
||||
(void)g; |
||||
writePinLow(ST7565_A0_PIN); |
||||
spiSend(&SPID1, 1, &cmd); |
||||
} |
||||
|
||||
static GFXINLINE void write_data(GDisplay *g, gU8 *data, gU16 length) { |
||||
(void)g; |
||||
writePinHigh(ST7565_A0_PIN); |
||||
spiSend(&SPID1, length, data); |
||||
} |
||||
|
||||
#endif /* _GDISP_LLD_BOARD_H */ |
||||
@ -1,27 +0,0 @@ |
||||
/**
|
||||
* This file has a different license to the rest of the uGFX system. |
||||
* You can copy, modify and distribute this file as you see fit. |
||||
* You do not need to publish your source modifications to this file. |
||||
* The only thing you are not permitted to do is to relicense it |
||||
* under a different license. |
||||
*/ |
||||
|
||||
/**
|
||||
* Copy this file into your project directory and rename it as gfxconf.h |
||||
* Edit your copy to turn on the uGFX features you want to use. |
||||
* The values below are the defaults. |
||||
* |
||||
* Only remove the comments from lines where you want to change the |
||||
* default value. This allows definitions to be included from |
||||
* driver makefiles when required and provides the best future |
||||
* compatibility for your project. |
||||
* |
||||
* Please use spaces instead of tabs in this file. |
||||
*/ |
||||
|
||||
#ifndef _GFXCONF_H |
||||
#define _GFXCONF_H |
||||
|
||||
#include "common_gfxconf.h" |
||||
|
||||
#endif /* _GFXCONF_H */ |
||||
@ -1,123 +0,0 @@ |
||||
/* Copyright 2017 Fred Sundvik
|
||||
* |
||||
* This program is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, either version 2 of the License, or |
||||
* (at your option) any later version. |
||||
* |
||||
* This program is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
|
||||
#ifndef KEYBOARDS_ERGODOX_INFINITY_SIMPLE_VISUALIZER_H_ |
||||
#define KEYBOARDS_ERGODOX_INFINITY_SIMPLE_VISUALIZER_H_ |
||||
|
||||
// Currently we are assuming that both the backlight and LCD are enabled
|
||||
// But it's entirely possible to write a custom visualizer that use only
|
||||
// one of them
|
||||
#ifndef LCD_BACKLIGHT_ENABLE |
||||
#error This visualizer needs that LCD backlight is enabled |
||||
#endif |
||||
|
||||
#ifndef LCD_ENABLE |
||||
#error This visualizer needs that LCD is enabled |
||||
#endif |
||||
|
||||
#include "visualizer.h" |
||||
#include "visualizer_keyframes.h" |
||||
#include "lcd_keyframes.h" |
||||
#include "lcd_backlight_keyframes.h" |
||||
#include "system/serial_link.h" |
||||
#include "led.h" |
||||
#include "default_animations.h" |
||||
|
||||
static const uint32_t logo_background_color = LCD_COLOR(0x00, 0x00, 0xFF); |
||||
static const uint32_t initial_color = LCD_COLOR(0, 0, 0); |
||||
|
||||
static bool initial_update = true; |
||||
|
||||
// Feel free to modify the animations below, or even add new ones if needed
|
||||
|
||||
static keyframe_animation_t lcd_layer_display = { |
||||
.num_frames = 1, |
||||
.loop = false, |
||||
.frame_lengths = {gfxMillisecondsToTicks(0)}, |
||||
.frame_functions = {lcd_keyframe_display_layer_and_led_states} |
||||
}; |
||||
|
||||
// The color animation animates the LCD color when you change layers
|
||||
static keyframe_animation_t color_animation = { |
||||
.num_frames = 2, |
||||
.loop = false, |
||||
// Note that there's a 200 ms no-operation frame,
|
||||
// this prevents the color from changing when activating the layer
|
||||
// momentarily
|
||||
.frame_lengths = {gfxMillisecondsToTicks(200), gfxMillisecondsToTicks(500)}, |
||||
.frame_functions = {keyframe_no_operation, lcd_backlight_keyframe_animate_color}, |
||||
}; |
||||
|
||||
void initialize_user_visualizer(visualizer_state_t* state) { |
||||
// The brightness will be dynamically adjustable in the future
|
||||
// But for now, change it here.
|
||||
lcd_backlight_brightness(130); |
||||
state->current_lcd_color = initial_color; |
||||
state->target_lcd_color = logo_background_color; |
||||
initial_update = true; |
||||
start_keyframe_animation(&default_startup_animation); |
||||
} |
||||
|
||||
|
||||
// This function should be implemented by the keymap visualizer
|
||||
// Don't change anything else than state->target_lcd_color and state->layer_text as that's the only thing
|
||||
// that the simple_visualizer assumes that you are updating
|
||||
// Also make sure that the buffer passed to state->layer_text remains valid until the previous animation is
|
||||
// stopped. This can be done by either double buffering it or by using constant strings
|
||||
static void get_visualizer_layer_and_color(visualizer_state_t* state); |
||||
|
||||
void update_user_visualizer_state(visualizer_state_t* state, visualizer_keyboard_status_t* prev_status) { |
||||
// Add more tests, change the colors and layer texts here
|
||||
// Usually you want to check the high bits (higher layers first)
|
||||
// because that's the order layers are processed for keypresses
|
||||
// You can for check for example:
|
||||
// state->status.layer
|
||||
// state->status.default_layer
|
||||
// state->status.leds (see led.h for available statuses)
|
||||
|
||||
uint32_t prev_color = state->target_lcd_color; |
||||
const char* prev_layer_text = state->layer_text; |
||||
|
||||
get_visualizer_layer_and_color(state); |
||||
|
||||
if (initial_update || prev_color != state->target_lcd_color) { |
||||
start_keyframe_animation(&color_animation); |
||||
} |
||||
|
||||
if (initial_update || prev_layer_text != state->layer_text) { |
||||
start_keyframe_animation(&lcd_layer_display); |
||||
} |
||||
// You can also stop existing animations, and start your custom ones here
|
||||
// remember that you should normally have only one animation for the LCD
|
||||
// and one for the background. But you can also combine them if you want.
|
||||
} |
||||
|
||||
void user_visualizer_suspend(visualizer_state_t* state) { |
||||
state->layer_text = "Suspending..."; |
||||
uint8_t hue = LCD_HUE(state->current_lcd_color); |
||||
uint8_t sat = LCD_SAT(state->current_lcd_color); |
||||
state->target_lcd_color = LCD_COLOR(hue, sat, 0); |
||||
start_keyframe_animation(&default_suspend_animation); |
||||
} |
||||
|
||||
void user_visualizer_resume(visualizer_state_t* state) { |
||||
state->current_lcd_color = initial_color; |
||||
state->target_lcd_color = logo_background_color; |
||||
initial_update = true; |
||||
start_keyframe_animation(&default_startup_animation); |
||||
} |
||||
|
||||
#endif /* KEYBOARDS_ERGODOX_INFINITY_SIMPLE_VISUALIZER_H_ */ |
||||
@ -1,328 +0,0 @@ |
||||
/*
|
||||
Copyright 2016 Fred Sundvik <fsundvik@gmail.com> |
||||
|
||||
This program is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License as published by |
||||
the Free Software Foundation, either version 2 of the License, or |
||||
(at your option) any later version. |
||||
|
||||
This program is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
|
||||
// Currently we are assuming that both the backlight and LCD are enabled
|
||||
// But it's entirely possible to write a custom visualizer that use only
|
||||
// one of them
|
||||
#ifndef LCD_BACKLIGHT_ENABLE |
||||
#error This visualizer needs that LCD backlight is enabled |
||||
#endif |
||||
|
||||
#ifndef LCD_ENABLE |
||||
#error This visualizer needs that LCD is enabled |
||||
#endif |
||||
|
||||
#include "visualizer.h" |
||||
#include "visualizer_keyframes.h" |
||||
#include "lcd_keyframes.h" |
||||
#include "lcd_backlight_keyframes.h" |
||||
#include "default_animations.h" |
||||
|
||||
static const uint32_t logo_background_color = LCD_COLOR(0x00, 0x00, 0xFF); |
||||
static const uint32_t initial_color = LCD_COLOR(0, 0, 0); |
||||
|
||||
static const uint32_t led_emulation_colors[4] = { |
||||
LCD_COLOR(0, 0, 0), |
||||
LCD_COLOR(255, 255, 255), |
||||
LCD_COLOR(84, 255, 255), |
||||
LCD_COLOR(168, 255, 255), |
||||
}; |
||||
|
||||
static uint32_t next_led_target_color = 0; |
||||
|
||||
typedef enum { |
||||
LCD_STATE_INITIAL, |
||||
LCD_STATE_LAYER_BITMAP, |
||||
LCD_STATE_BITMAP_AND_LEDS, |
||||
} lcd_state_t; |
||||
|
||||
static lcd_state_t lcd_state = LCD_STATE_INITIAL; |
||||
|
||||
typedef struct { |
||||
uint8_t led_on; |
||||
uint8_t led1; |
||||
uint8_t led2; |
||||
uint8_t led3; |
||||
} visualizer_user_data_t; |
||||
|
||||
// Don't access from visualization function, use the visualizer state instead
|
||||
static visualizer_user_data_t user_data_keyboard = { |
||||
.led_on = 0, |
||||
.led1 = LED_BRIGHTNESS_HI, |
||||
.led2 = LED_BRIGHTNESS_HI, |
||||
.led3 = LED_BRIGHTNESS_HI, |
||||
}; |
||||
|
||||
_Static_assert(sizeof(visualizer_user_data_t) <= VISUALIZER_USER_DATA_SIZE, |
||||
"Please increase the VISUALIZER_USER_DATA_SIZE"); |
||||
|
||||
// Feel free to modify the animations below, or even add new ones if needed
|
||||
|
||||
|
||||
// The color animation animates the LCD color when you change layers
|
||||
static keyframe_animation_t one_led_color = { |
||||
.num_frames = 1, |
||||
.loop = false, |
||||
.frame_lengths = {gfxMillisecondsToTicks(0)}, |
||||
.frame_functions = {lcd_backlight_keyframe_set_color}, |
||||
}; |
||||
|
||||
bool swap_led_target_color(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
uint32_t temp = next_led_target_color; |
||||
next_led_target_color = state->target_lcd_color; |
||||
state->target_lcd_color = temp; |
||||
return false; |
||||
} |
||||
|
||||
// The color animation animates the LCD color when you change layers
|
||||
static keyframe_animation_t two_led_colors = { |
||||
.num_frames = 2, |
||||
.loop = true, |
||||
.frame_lengths = {gfxMillisecondsToTicks(1000), gfxMillisecondsToTicks(0)}, |
||||
.frame_functions = {lcd_backlight_keyframe_set_color, swap_led_target_color}, |
||||
}; |
||||
|
||||
// The LCD animation alternates between the layer name display and a
|
||||
// bitmap that displays all active layers
|
||||
static keyframe_animation_t lcd_bitmap_animation = { |
||||
.num_frames = 1, |
||||
.loop = false, |
||||
.frame_lengths = {gfxMillisecondsToTicks(0)}, |
||||
.frame_functions = {lcd_keyframe_display_layer_bitmap}, |
||||
}; |
||||
|
||||
static keyframe_animation_t lcd_bitmap_leds_animation = { |
||||
.num_frames = 2, |
||||
.loop = true, |
||||
.frame_lengths = {gfxMillisecondsToTicks(2000), gfxMillisecondsToTicks(2000)}, |
||||
.frame_functions = {lcd_keyframe_display_layer_bitmap, lcd_keyframe_display_led_states}, |
||||
}; |
||||
|
||||
void initialize_user_visualizer(visualizer_state_t* state) { |
||||
// The brightness will be dynamically adjustable in the future
|
||||
// But for now, change it here.
|
||||
lcd_backlight_brightness(130); |
||||
state->current_lcd_color = initial_color; |
||||
state->target_lcd_color = logo_background_color; |
||||
lcd_state = LCD_STATE_INITIAL; |
||||
start_keyframe_animation(&default_startup_animation); |
||||
} |
||||
|
||||
static inline bool is_led_on(visualizer_user_data_t* user_data, uint8_t num) { |
||||
return user_data->led_on & (1u << num); |
||||
} |
||||
|
||||
static uint8_t get_led_index_master(visualizer_user_data_t* user_data) { |
||||
for (int i=0; i < 3; i++) { |
||||
if (is_led_on(user_data, i)) { |
||||
return i + 1; |
||||
} |
||||
} |
||||
return 0; |
||||
} |
||||
|
||||
static uint8_t get_led_index_slave(visualizer_user_data_t* user_data) { |
||||
uint8_t master_index = get_led_index_master(user_data); |
||||
if (master_index!=0) { |
||||
for (int i=master_index; i < 3; i++) { |
||||
if (is_led_on(user_data, i)) { |
||||
return i + 1; |
||||
} |
||||
} |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static uint8_t get_secondary_led_index(visualizer_user_data_t* user_data) { |
||||
if (is_led_on(user_data, 0) && |
||||
is_led_on(user_data, 1) && |
||||
is_led_on(user_data, 2)) { |
||||
return 3; |
||||
} |
||||
return 0; |
||||
} |
||||
|
||||
static uint8_t get_brightness(visualizer_user_data_t* user_data, uint8_t index) { |
||||
switch (index) { |
||||
case 1: |
||||
return user_data->led1; |
||||
case 2: |
||||
return user_data->led2; |
||||
case 3: |
||||
return user_data->led3; |
||||
} |
||||
return 0; |
||||
} |
||||
|
||||
static void update_emulated_leds(visualizer_state_t* state, visualizer_keyboard_status_t* prev_status) { |
||||
visualizer_user_data_t* user_data_new = (visualizer_user_data_t*)state->status.user_data; |
||||
visualizer_user_data_t* user_data_old = (visualizer_user_data_t*)prev_status->user_data; |
||||
|
||||
uint8_t new_index; |
||||
uint8_t old_index; |
||||
|
||||
if (is_keyboard_master()) { |
||||
new_index = get_led_index_master(user_data_new); |
||||
old_index = get_led_index_master(user_data_old); |
||||
} |
||||
else { |
||||
new_index = get_led_index_slave(user_data_new); |
||||
old_index = get_led_index_slave(user_data_old); |
||||
} |
||||
uint8_t new_secondary_index = get_secondary_led_index(user_data_new); |
||||
uint8_t old_secondary_index = get_secondary_led_index(user_data_old); |
||||
|
||||
uint8_t old_brightness = get_brightness(user_data_old, old_index); |
||||
uint8_t new_brightness = get_brightness(user_data_new, new_index); |
||||
|
||||
uint8_t old_secondary_brightness = get_brightness(user_data_old, old_secondary_index); |
||||
uint8_t new_secondary_brightness = get_brightness(user_data_new, new_secondary_index); |
||||
|
||||
if (lcd_state == LCD_STATE_INITIAL || |
||||
new_index != old_index || |
||||
new_secondary_index != old_secondary_index || |
||||
new_brightness != old_brightness || |
||||
new_secondary_brightness != old_secondary_brightness) { |
||||
|
||||
if (new_secondary_index != 0) { |
||||
state->target_lcd_color = change_lcd_color_intensity( |
||||
led_emulation_colors[new_index], new_brightness); |
||||
next_led_target_color = change_lcd_color_intensity( |
||||
led_emulation_colors[new_secondary_index], new_secondary_brightness); |
||||
|
||||
stop_keyframe_animation(&one_led_color); |
||||
start_keyframe_animation(&two_led_colors); |
||||
} else { |
||||
state->target_lcd_color = change_lcd_color_intensity( |
||||
led_emulation_colors[new_index], new_brightness); |
||||
stop_keyframe_animation(&two_led_colors); |
||||
start_keyframe_animation(&one_led_color); |
||||
} |
||||
} |
||||
} |
||||
|
||||
static void update_lcd_text(visualizer_state_t* state, visualizer_keyboard_status_t* prev_status) { |
||||
if (state->status.leds) { |
||||
if (lcd_state != LCD_STATE_BITMAP_AND_LEDS || |
||||
state->status.leds != prev_status->leds || |
||||
state->status.layer != prev_status->layer || |
||||
state->status.default_layer != prev_status->default_layer) { |
||||
|
||||
// NOTE: that it doesn't matter if the animation isn't playing, stop will do nothing in that case
|
||||
stop_keyframe_animation(&lcd_bitmap_animation); |
||||
|
||||
lcd_state = LCD_STATE_BITMAP_AND_LEDS; |
||||
// For information:
|
||||
// The logic in this function makes sure that this doesn't happen, but if you call start on an
|
||||
// animation that is already playing it will be restarted.
|
||||
start_keyframe_animation(&lcd_bitmap_leds_animation); |
||||
} |
||||
} else { |
||||
if (lcd_state != LCD_STATE_LAYER_BITMAP || |
||||
state->status.layer != prev_status->layer || |
||||
state->status.default_layer != prev_status->default_layer) { |
||||
|
||||
stop_keyframe_animation(&lcd_bitmap_leds_animation); |
||||
|
||||
lcd_state = LCD_STATE_LAYER_BITMAP; |
||||
start_keyframe_animation(&lcd_bitmap_animation); |
||||
} |
||||
} |
||||
} |
||||
|
||||
void update_user_visualizer_state(visualizer_state_t* state, visualizer_keyboard_status_t* prev_status) { |
||||
// Check the status here to start and stop animations
|
||||
// You might have to save some state, like the current animation here so that you can start the right
|
||||
// This function is called every time the status changes
|
||||
|
||||
// NOTE that this is called from the visualizer thread, so don't access anything else outside the status
|
||||
// This is also important because the slave won't have access to the active layer for example outside the
|
||||
// status.
|
||||
|
||||
update_emulated_leds(state, prev_status); |
||||
update_lcd_text(state, prev_status); |
||||
|
||||
} |
||||
|
||||
void user_visualizer_suspend(visualizer_state_t* state) { |
||||
state->layer_text = "Suspending..."; |
||||
uint8_t hue = LCD_HUE(state->current_lcd_color); |
||||
uint8_t sat = LCD_SAT(state->current_lcd_color); |
||||
state->target_lcd_color = LCD_COLOR(hue, sat, 0); |
||||
start_keyframe_animation(&default_suspend_animation); |
||||
} |
||||
|
||||
void user_visualizer_resume(visualizer_state_t* state) { |
||||
state->current_lcd_color = initial_color; |
||||
state->target_lcd_color = logo_background_color; |
||||
lcd_state = LCD_STATE_INITIAL; |
||||
start_keyframe_animation(&default_startup_animation); |
||||
} |
||||
|
||||
void ergodox_board_led_on(void){ |
||||
// No board led support
|
||||
} |
||||
|
||||
void ergodox_right_led_1_on(void){ |
||||
user_data_keyboard.led_on |= (1u << 0); |
||||
visualizer_set_user_data(&user_data_keyboard); |
||||
} |
||||
|
||||
void ergodox_right_led_2_on(void){ |
||||
user_data_keyboard.led_on |= (1u << 1); |
||||
visualizer_set_user_data(&user_data_keyboard); |
||||
} |
||||
|
||||
void ergodox_right_led_3_on(void){ |
||||
user_data_keyboard.led_on |= (1u << 2); |
||||
visualizer_set_user_data(&user_data_keyboard); |
||||
} |
||||
|
||||
void ergodox_board_led_off(void){ |
||||
// No board led support
|
||||
} |
||||
|
||||
void ergodox_right_led_1_off(void){ |
||||
user_data_keyboard.led_on &= ~(1u << 0); |
||||
visualizer_set_user_data(&user_data_keyboard); |
||||
} |
||||
|
||||
void ergodox_right_led_2_off(void){ |
||||
user_data_keyboard.led_on &= ~(1u << 1); |
||||
visualizer_set_user_data(&user_data_keyboard); |
||||
} |
||||
|
||||
void ergodox_right_led_3_off(void){ |
||||
user_data_keyboard.led_on &= ~(1u << 2); |
||||
visualizer_set_user_data(&user_data_keyboard); |
||||
} |
||||
|
||||
void ergodox_right_led_1_set(uint8_t n) { |
||||
user_data_keyboard.led1 = n; |
||||
visualizer_set_user_data(&user_data_keyboard); |
||||
} |
||||
|
||||
void ergodox_right_led_2_set(uint8_t n) { |
||||
user_data_keyboard.led2 = n; |
||||
visualizer_set_user_data(&user_data_keyboard); |
||||
} |
||||
|
||||
void ergodox_right_led_3_set(uint8_t n) { |
||||
user_data_keyboard.led3 = n; |
||||
visualizer_set_user_data(&user_data_keyboard); |
||||
} |
||||
@ -1,27 +0,0 @@ |
||||
/**
|
||||
* This file has a different license to the rest of the uGFX system. |
||||
* You can copy, modify and distribute this file as you see fit. |
||||
* You do not need to publish your source modifications to this file. |
||||
* The only thing you are not permitted to do is to relicense it |
||||
* under a different license. |
||||
*/ |
||||
|
||||
/**
|
||||
* Copy this file into your project directory and rename it as gfxconf.h |
||||
* Edit your copy to turn on the uGFX features you want to use. |
||||
* The values below are the defaults. |
||||
* |
||||
* Only remove the comments from lines where you want to change the |
||||
* default value. This allows definitions to be included from |
||||
* driver makefiles when required and provides the best future |
||||
* compatibility for your project. |
||||
* |
||||
* Please use spaces instead of tabs in this file. |
||||
*/ |
||||
|
||||
#ifndef _GFXCONF_H |
||||
#define _GFXCONF_H |
||||
|
||||
#include "common_gfxconf.h" |
||||
|
||||
#endif /* _GFXCONF_H */ |
||||
@ -1,54 +0,0 @@ |
||||
/* Copyright 2017 Fred Sundvik
|
||||
* |
||||
* This program is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, either version 2 of the License, or |
||||
* (at your option) any later version. |
||||
* |
||||
* This program is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
|
||||
#include "visualizer.h" |
||||
#include "visualizer_keyframes.h" |
||||
#include "default_animations.h" |
||||
|
||||
static bool initial_update = true; |
||||
|
||||
// Feel free to modify the animations below, or even add new ones if needed
|
||||
|
||||
void initialize_user_visualizer(visualizer_state_t *state) { |
||||
// The brightness will be dynamically adjustable in the future
|
||||
// But for now, change it here.
|
||||
initial_update = true; |
||||
start_keyframe_animation(&default_startup_animation); |
||||
} |
||||
|
||||
void update_user_visualizer_state(visualizer_state_t *state, visualizer_keyboard_status_t *prev_status) { |
||||
// Add more tests, change the colors and layer texts here
|
||||
// Usually you want to check the high bits (higher layers first)
|
||||
// because that's the order layers are processed for keypresses
|
||||
// You can for check for example:
|
||||
// state->status.layer
|
||||
// state->status.default_layer
|
||||
// state->status.leds (see led.h for available statuses)
|
||||
|
||||
if (initial_update) { |
||||
initial_update = false; |
||||
start_keyframe_animation(&led_test_animation); |
||||
} |
||||
} |
||||
|
||||
void user_visualizer_suspend(visualizer_state_t *state) { |
||||
start_keyframe_animation(&default_suspend_animation); |
||||
} |
||||
|
||||
void user_visualizer_resume(visualizer_state_t *state) { |
||||
initial_update = true; |
||||
start_keyframe_animation(&default_startup_animation); |
||||
} |
||||
@ -1 +0,0 @@ |
||||
Subproject commit 40b48f470addad6a4fb1177de1a69a181158739b |
||||
@ -1,29 +0,0 @@ |
||||
The files in this project are licensed under the MIT license |
||||
It uses the following libraries |
||||
uGFX - with it's own license, see the license.html file in the uGFX subfolder for more information |
||||
tmk_core - is indirectly used and not included in the repository. It's licensed under the GPLv2 license |
||||
Chibios - which is used by tmk_core is licensed under GPLv3. |
||||
|
||||
Therefore the effective license for any project using the library is GPLv3 |
||||
|
||||
The MIT License (MIT) |
||||
|
||||
Copyright (c) 2016 Fred Sundvik |
||||
|
||||
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. |
||||
@ -1,354 +0,0 @@ |
||||
/**
|
||||
* This file has a different license to the rest of the uGFX system. |
||||
* You can copy, modify and distribute this file as you see fit. |
||||
* You do not need to publish your source modifications to this file. |
||||
* The only thing you are not permitted to do is to relicense it |
||||
* under a different license. |
||||
*/ |
||||
|
||||
/**
|
||||
* Copy this file into your project directory and rename it as gfxconf.h |
||||
* Edit your copy to turn on the uGFX features you want to use. |
||||
* The values below are the defaults. |
||||
* |
||||
* Only remove the comments from lines where you want to change the |
||||
* default value. This allows definitions to be included from |
||||
* driver makefiles when required and provides the best future |
||||
* compatibility for your project. |
||||
* |
||||
* Please use spaces instead of tabs in this file. |
||||
*/ |
||||
|
||||
#pragma once |
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// GFX - Compatibility options //
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//#define GFX_COMPAT_V2 GFXON
|
||||
//#define GFX_COMPAT_OLDCOLORS GFXON
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// GOS - One of these must be defined, preferably in your Makefile //
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//#define GFX_USE_OS_CHIBIOS GFXOFF
|
||||
//#define GFX_USE_OS_FREERTOS GFXOFF
|
||||
// #define GFX_FREERTOS_USE_TRACE GFXOFF
|
||||
//#define GFX_USE_OS_WIN32 GFXOFF
|
||||
//#define GFX_USE_OS_LINUX GFXOFF
|
||||
//#define GFX_USE_OS_OSX GFXOFF
|
||||
//#define GFX_USE_OS_ECOS GFXOFF
|
||||
//#define GFX_USE_OS_RAWRTOS GFXOFF
|
||||
//#define GFX_USE_OS_ARDUINO GFXOFF
|
||||
//#define GFX_USE_OS_KEIL GFXOFF
|
||||
//#define GFX_USE_OS_RTX5 GFXOFF
|
||||
//#define GFX_USE_OS_CMSIS GFXOFF
|
||||
//#define GFX_USE_OS_CMSIS2 GFXOFF
|
||||
//#define GFX_USE_OS_RAW32 GFXOFF
|
||||
//#define GFX_USE_OS_ZEPHYR GFXOFF
|
||||
//#define GFX_USE_OS_NIOS GFXOFF
|
||||
//#define GFX_USE_OS_QT GFXOFF
|
||||
// #define INTERRUPTS_OFF() optional_code
|
||||
// #define INTERRUPTS_ON() optional_code
|
||||
|
||||
// Options that (should where relevant) apply to all operating systems
|
||||
#define GFX_NO_INLINE GFXON |
||||
// #define GFX_COMPILER GFX_COMPILER_UNKNOWN
|
||||
// #define GFX_SHOW_COMPILER GFXOFF
|
||||
// #define GFX_CPU GFX_CPU_UNKNOWN
|
||||
// #define GFX_CPU_NO_ALIGNMENT_FAULTS GFXOFF
|
||||
// #define GFX_CPU_ENDIAN GFX_CPU_ENDIAN_UNKNOWN
|
||||
// #define GFX_OS_HEAP_SIZE 0
|
||||
// #define GFX_OS_NO_INIT GFXOFF
|
||||
// #define GFX_OS_INIT_NO_WARNING GFXOFF
|
||||
// #define GFX_OS_PRE_INIT_FUNCTION myHardwareInitRoutine
|
||||
// #define GFX_OS_EXTRA_INIT_FUNCTION myOSInitRoutine
|
||||
// #define GFX_OS_EXTRA_DEINIT_FUNCTION myOSDeInitRoutine
|
||||
// #define GFX_OS_CALL_UGFXMAIN GFXOFF
|
||||
// #define GFX_OS_UGFXMAIN_STACKSIZE 0
|
||||
// #define GFX_EMULATE_MALLOC GFXOFF
|
||||
// #define GFX_MEM_LT64K GFXOFF
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// GDISP //
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
#define GFX_USE_GDISP GFXON |
||||
|
||||
//#define GDISP_NEED_AUTOFLUSH GFXOFF
|
||||
//#define GDISP_NEED_TIMERFLUSH GFXOFF
|
||||
//#define GDISP_NEED_VALIDATION GFXON
|
||||
//#define GDISP_NEED_CLIP GFXON
|
||||
#define GDISP_NEED_CIRCLE GFXON |
||||
//#define GDISP_NEED_DUALCIRCLE GFXOFF
|
||||
#define GDISP_NEED_ELLIPSE GFXON |
||||
#define GDISP_NEED_ARC GFXON |
||||
#define GDISP_NEED_ARCSECTORS GFXON |
||||
#define GDISP_NEED_CONVEX_POLYGON GFXON |
||||
//#define GDISP_NEED_SCROLL GFXOFF
|
||||
#define GDISP_NEED_PIXELREAD GFXON |
||||
#define GDISP_NEED_CONTROL GFXON |
||||
//#define GDISP_NEED_QUERY GFXOFF
|
||||
//#define GDISP_NEED_MULTITHREAD GFXOFF
|
||||
//#define GDISP_NEED_STREAMING GFXOFF
|
||||
#define GDISP_NEED_TEXT GFXON |
||||
// #define GDISP_NEED_TEXT_WORDWRAP GFXOFF
|
||||
// #define GDISP_NEED_TEXT_BOXPADLR 1
|
||||
// #define GDISP_NEED_TEXT_BOXPADTB 1
|
||||
// #define GDISP_NEED_ANTIALIAS GFXOFF
|
||||
// #define GDISP_NEED_UTF8 GFXOFF
|
||||
#define GDISP_NEED_TEXT_KERNING GFXON |
||||
// #define GDISP_INCLUDE_FONT_UI1 GFXOFF
|
||||
// #define GDISP_INCLUDE_FONT_UI2 GFXOFF // The smallest preferred font.
|
||||
// #define GDISP_INCLUDE_FONT_LARGENUMBERS GFXOFF
|
||||
// #define GDISP_INCLUDE_FONT_DEJAVUSANS10 GFXOFF
|
||||
// #define GDISP_INCLUDE_FONT_DEJAVUSANS12 GFXOFF
|
||||
// #define GDISP_INCLUDE_FONT_DEJAVUSANS16 GFXOFF
|
||||
// #define GDISP_INCLUDE_FONT_DEJAVUSANS20 GFXOFF
|
||||
// #define GDISP_INCLUDE_FONT_DEJAVUSANS24 GFXOFF
|
||||
// #define GDISP_INCLUDE_FONT_DEJAVUSANS32 GFXOFF
|
||||
#define GDISP_INCLUDE_FONT_DEJAVUSANSBOLD12 GFXON |
||||
// #define GDISP_INCLUDE_FONT_FIXED_10X20 GFXOFF
|
||||
// #define GDISP_INCLUDE_FONT_FIXED_7X14 GFXOFF
|
||||
#define GDISP_INCLUDE_FONT_FIXED_5X8 GFXON |
||||
// #define GDISP_INCLUDE_FONT_DEJAVUSANS12_AA GFXOFF
|
||||
// #define GDISP_INCLUDE_FONT_DEJAVUSANS16_AA GFXOFF
|
||||
// #define GDISP_INCLUDE_FONT_DEJAVUSANS20_AA GFXOFF
|
||||
// #define GDISP_INCLUDE_FONT_DEJAVUSANS24_AA GFXOFF
|
||||
// #define GDISP_INCLUDE_FONT_DEJAVUSANS32_AA GFXOFF
|
||||
// #define GDISP_INCLUDE_FONT_DEJAVUSANSBOLD12_AA GFXOFF
|
||||
// #define GDISP_INCLUDE_USER_FONTS GFXOFF
|
||||
|
||||
//#define GDISP_NEED_IMAGE GFXOFF
|
||||
// #define GDISP_NEED_IMAGE_NATIVE GFXOFF
|
||||
// #define GDISP_NEED_IMAGE_GIF GFXOFF
|
||||
// #define GDISP_IMAGE_GIF_BLIT_BUFFER_SIZE 32
|
||||
// #define GDISP_NEED_IMAGE_BMP GFXOFF
|
||||
// #define GDISP_NEED_IMAGE_BMP_1 GFXON
|
||||
// #define GDISP_NEED_IMAGE_BMP_4 GFXON
|
||||
// #define GDISP_NEED_IMAGE_BMP_4_RLE GFXON
|
||||
// #define GDISP_NEED_IMAGE_BMP_8 GFXON
|
||||
// #define GDISP_NEED_IMAGE_BMP_8_RLE GFXON
|
||||
// #define GDISP_NEED_IMAGE_BMP_16 GFXON
|
||||
// #define GDISP_NEED_IMAGE_BMP_24 GFXON
|
||||
// #define GDISP_NEED_IMAGE_BMP_32 GFXON
|
||||
// #define GDISP_IMAGE_BMP_BLIT_BUFFER_SIZE 32
|
||||
// #define GDISP_NEED_IMAGE_JPG GFXOFF
|
||||
// #define GDISP_NEED_IMAGE_PNG GFXOFF
|
||||
// #define GDISP_NEED_IMAGE_PNG_INTERLACED GFXOFF
|
||||
// #define GDISP_NEED_IMAGE_PNG_TRANSPARENCY GFXON
|
||||
// #define GDISP_NEED_IMAGE_PNG_BACKGROUND GFXON
|
||||
// #define GDISP_NEED_IMAGE_PNG_ALPHACLIFF 32
|
||||
// #define GDISP_NEED_IMAGE_PNG_PALETTE_124 GFXON
|
||||
// #define GDISP_NEED_IMAGE_PNG_PALETTE_8 GFXON
|
||||
// #define GDISP_NEED_IMAGE_PNG_GRAYSCALE_124 GFXON
|
||||
// #define GDISP_NEED_IMAGE_PNG_GRAYSCALE_8 GFXON
|
||||
// #define GDISP_NEED_IMAGE_PNG_GRAYSCALE_16 GFXON
|
||||
// #define GDISP_NEED_IMAGE_PNG_GRAYALPHA_8 GFXON
|
||||
// #define GDISP_NEED_IMAGE_PNG_GRAYALPHA_16 GFXON
|
||||
// #define GDISP_NEED_IMAGE_PNG_RGB_8 GFXON
|
||||
// #define GDISP_NEED_IMAGE_PNG_RGB_16 GFXON
|
||||
// #define GDISP_NEED_IMAGE_PNG_RGBALPHA_8 GFXON
|
||||
// #define GDISP_NEED_IMAGE_PNG_RGBALPHA_16 GFXON
|
||||
// #define GDISP_IMAGE_PNG_BLIT_BUFFER_SIZE 32
|
||||
// #define GDISP_IMAGE_PNG_FILE_BUFFER_SIZE 8
|
||||
// #define GDISP_IMAGE_PNG_Z_BUFFER_SIZE 32768
|
||||
// #define GDISP_NEED_IMAGE_ACCOUNTING GFXOFF
|
||||
|
||||
//#define GDISP_NEED_PIXMAP GFXOFF
|
||||
// #define GDISP_NEED_PIXMAP_IMAGE GFXOFF
|
||||
|
||||
//#define GDISP_DEFAULT_ORIENTATION gOrientationLandscape // If not defined the native hardware orientation is used.
|
||||
//#define GDISP_LINEBUF_SIZE 128
|
||||
//#define GDISP_STARTUP_COLOR GFX_BLACK
|
||||
#define GDISP_NEED_STARTUP_LOGO GFXOFF |
||||
|
||||
//#define GDISP_TOTAL_DISPLAYS 1
|
||||
|
||||
//#define GDISP_DRIVER_LIST GDISPVMT_Win32, GDISPVMT_Win32
|
||||
#ifdef GDISP_DRIVER_LIST |
||||
// // For code and speed optimization define as GFXON or GFXOFF if all controllers have the same capability
|
||||
# define GDISP_HARDWARE_STREAM_WRITE GFXOFF |
||||
# define GDISP_HARDWARE_STREAM_READ GFXOFF |
||||
# define GDISP_HARDWARE_STREAM_POS GFXOFF |
||||
# define GDISP_HARDWARE_DRAWPIXEL GFXON |
||||
# define GDISP_HARDWARE_CLEARS GFXOFF |
||||
# define GDISP_HARDWARE_FILLS GFXOFF |
||||
//#define GDISP_HARDWARE_BITFILLS GFXOFF
|
||||
# define GDISP_HARDWARE_SCROLL GFXOFF |
||||
# define GDISP_HARDWARE_PIXELREAD GFXON |
||||
# define GDISP_HARDWARE_CONTROL GFXON |
||||
# define GDISP_HARDWARE_QUERY GFXOFF |
||||
# define GDISP_HARDWARE_CLIP GFXOFF |
||||
|
||||
# define GDISP_PIXELFORMAT GDISP_PIXELFORMAT_RGB888 |
||||
#endif |
||||
|
||||
#define GDISP_USE_GFXNET GFXOFF |
||||
// #define GDISP_GFXNET_PORT 13001
|
||||
// #define GDISP_GFXNET_CUSTOM_LWIP_STARTUP GFXOFF
|
||||
// #define GDISP_DONT_WAIT_FOR_NET_DISPLAY GFXOFF
|
||||
// #define GDISP_GFXNET_UNSAFE_SOCKETS GFXOFF
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// GWIN //
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
#define GFX_USE_GWIN GFXOFF |
||||
|
||||
//#define GWIN_NEED_WINDOWMANAGER GFXOFF
|
||||
// #define GWIN_REDRAW_IMMEDIATE GFXOFF
|
||||
// #define GWIN_REDRAW_SINGLEOP GFXOFF
|
||||
// #define GWIN_NEED_FLASHING GFXOFF
|
||||
// #define GWIN_FLASHING_PERIOD 250
|
||||
|
||||
//#define GWIN_NEED_CONSOLE GFXOFF
|
||||
// #define GWIN_CONSOLE_USE_HISTORY GFXOFF
|
||||
// #define GWIN_CONSOLE_HISTORY_AVERAGING GFXOFF
|
||||
// #define GWIN_CONSOLE_HISTORY_ATCREATE GFXOFF
|
||||
// #define GWIN_CONSOLE_ESCSEQ GFXOFF
|
||||
// #define GWIN_CONSOLE_USE_BASESTREAM GFXOFF
|
||||
// #define GWIN_CONSOLE_USE_FLOAT GFXOFF
|
||||
//#define GWIN_NEED_GRAPH GFXOFF
|
||||
//#define GWIN_NEED_GL3D GFXOFF
|
||||
|
||||
//#define GWIN_NEED_WIDGET GFXOFF
|
||||
//#define GWIN_FOCUS_HIGHLIGHT_WIDTH 1
|
||||
// #define GWIN_NEED_LABEL GFXOFF
|
||||
// #define GWIN_LABEL_ATTRIBUTE GFXOFF
|
||||
// #define GWIN_NEED_BUTTON GFXOFF
|
||||
// #define GWIN_BUTTON_LAZY_RELEASE GFXOFF
|
||||
// #define GWIN_NEED_SLIDER GFXOFF
|
||||
// #define GWIN_SLIDER_NOSNAP GFXOFF
|
||||
// #define GWIN_SLIDER_DEAD_BAND 5
|
||||
// #define GWIN_SLIDER_TOGGLE_INC 20
|
||||
// #define GWIN_NEED_CHECKBOX GFXOFF
|
||||
// #define GWIN_NEED_IMAGE GFXOFF
|
||||
// #define GWIN_NEED_IMAGE_ANIMATION GFXOFF
|
||||
// #define GWIN_NEED_RADIO GFXOFF
|
||||
// #define GWIN_NEED_LIST GFXOFF
|
||||
// #define GWIN_NEED_LIST_IMAGES GFXOFF
|
||||
// #define GWIN_NEED_PROGRESSBAR GFXOFF
|
||||
// #define GWIN_PROGRESSBAR_AUTO GFXOFF
|
||||
// #define GWIN_NEED_KEYBOARD GFXOFF
|
||||
// #define GWIN_KEYBOARD_DEFAULT_LAYOUT VirtualKeyboard_English1
|
||||
// #define GWIN_NEED_KEYBOARD_ENGLISH1 GFXON
|
||||
// #define GWIN_NEED_TEXTEDIT GFXOFF
|
||||
// #define GWIN_FLAT_STYLING GFXOFF
|
||||
// #define GWIN_WIDGET_TAGS GFXOFF
|
||||
|
||||
//#define GWIN_NEED_CONTAINERS GFXOFF
|
||||
// #define GWIN_NEED_CONTAINER GFXOFF
|
||||
// #define GWIN_NEED_FRAME GFXOFF
|
||||
// #define GWIN_NEED_TABSET GFXOFF
|
||||
// #define GWIN_TABSET_TABHEIGHT 18
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// GTRANS //
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
//#define GFX_USE_GTRANS GFXOFF
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// GEVENT //
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
#define GFX_USE_GEVENT GFXON |
||||
|
||||
//#define GEVENT_ASSERT_NO_RESOURCE GFXOFF
|
||||
//#define GEVENT_MAXIMUM_SIZE 32
|
||||
//#define GEVENT_MAX_SOURCE_LISTENERS 32
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// GTIMER //
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
#define GFX_USE_GTIMER GFXOFF |
||||
|
||||
//#define GTIMER_THREAD_PRIORITY gThreadpriorityHigh
|
||||
//#define GTIMER_THREAD_WORKAREA_SIZE 2048
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// GQUEUE //
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
#define GFX_USE_GQUEUE GFXOFF |
||||
|
||||
//#define GQUEUE_NEED_ASYNC GFXOFF
|
||||
//#define GQUEUE_NEED_GSYNC GFXOFF
|
||||
//#define GQUEUE_NEED_FSYNC GFXOFF
|
||||
//#define GQUEUE_NEED_BUFFERS GFXOFF
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// GINPUT //
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
#define GFX_USE_GINPUT GFXOFF |
||||
|
||||
//#define GINPUT_NEED_MOUSE GFXOFF
|
||||
// #define GINPUT_TOUCH_STARTRAW GFXOFF
|
||||
// #define GINPUT_TOUCH_NOTOUCH GFXOFF
|
||||
// #define GINPUT_TOUCH_NOCALIBRATE GFXOFF
|
||||
// #define GINPUT_TOUCH_NOCALIBRATE_GUI GFXOFF
|
||||
// #define GINPUT_MOUSE_POLL_PERIOD 25
|
||||
// #define GINPUT_MOUSE_CLICK_TIME 300
|
||||
// #define GINPUT_TOUCH_CXTCLICK_TIME 700
|
||||
// #define GINPUT_TOUCH_USER_CALIBRATION_LOAD GFXOFF
|
||||
// #define GINPUT_TOUCH_USER_CALIBRATION_SAVE GFXOFF
|
||||
// #define GMOUSE_DRIVER_LIST GMOUSEVMT_Win32, GMOUSEVMT_Win32
|
||||
// #define GINPUT_TOUCH_CALIBRATION_FONT1 "* Double"
|
||||
// #define GINPUT_TOUCH_CALIBRATION_FONT2 "* Narrow"
|
||||
// #define GINPUT_TOUCH_CALIBRATION_TITLE "Calibration"
|
||||
// #define GINPUT_TOUCH_CALIBRATION_ERROR "Calibration Failed!"
|
||||
//#define GINPUT_NEED_KEYBOARD GFXOFF
|
||||
// #define GINPUT_KEYBOARD_POLL_PERIOD 200
|
||||
// #define GKEYBOARD_DRIVER_LIST GKEYBOARDVMT_Win32, GKEYBOARDVMT_Win32
|
||||
// #define GKEYBOARD_LAYOUT_OFF GFXOFF
|
||||
// #define GKEYBOARD_LAYOUT_SCANCODE2_US GFXOFF
|
||||
//#define GINPUT_NEED_TOGGLE GFXOFF
|
||||
//#define GINPUT_NEED_DIAL GFXOFF
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// GFILE //
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
#define GFX_USE_GFILE GFXOFF |
||||
|
||||
//#define GFILE_NEED_PRINTG GFXOFF
|
||||
//#define GFILE_NEED_SCANG GFXOFF
|
||||
//#define GFILE_NEED_STRINGS GFXOFF
|
||||
//#define GFILE_NEED_FILELISTS GFXOFF
|
||||
//#define GFILE_NEED_STDIO GFXOFF
|
||||
//#define GFILE_NEED_NOAUTOMOUNT GFXOFF
|
||||
//#define GFILE_NEED_NOAUTOSYNC GFXOFF
|
||||
|
||||
//#define GFILE_NEED_MEMFS GFXOFF
|
||||
//#define GFILE_NEED_ROMFS GFXOFF
|
||||
//#define GFILE_NEED_RAMFS GFXOFF
|
||||
//#define GFILE_NEED_FATFS GFXOFF
|
||||
//#define GFILE_NEED_NATIVEFS GFXOFF
|
||||
//#define GFILE_NEED_CHBIOSFS GFXOFF
|
||||
//#define GFILE_NEED_USERFS GFXOFF
|
||||
|
||||
//#define GFILE_ALLOW_FLOATS GFXOFF
|
||||
//#define GFILE_ALLOW_DEVICESPECIFIC GFXOFF
|
||||
//#define GFILE_MAX_GFILES 3
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// GADC //
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
#define GFX_USE_GADC GFXOFF |
||||
// #define GADC_MAX_LOWSPEED_DEVICES 4
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// GAUDIO //
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
#define GFX_USE_GAUDIO GFXOFF |
||||
// #define GAUDIO_NEED_PLAY GFXOFF
|
||||
// #define GAUDIO_NEED_RECORD GFXOFF
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// GMISC //
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
#define GFX_USE_GMISC GFXON |
||||
|
||||
//#define GMISC_NEED_ARRAYOPS GFXOFF
|
||||
//#define GMISC_NEED_FASTTRIG GFXOFF
|
||||
//#define GMISC_NEED_FIXEDTRIG GFXOFF
|
||||
//#define GMISC_NEED_INVSQRT GFXOFF
|
||||
// #define GMISC_INVSQRT_MIXED_ENDIAN GFXOFF
|
||||
// #define GMISC_INVSQRT_REAL_SLOW GFXOFF
|
||||
#define GMISC_NEED_MATRIXFLOAT2D GFXON |
||||
#define GMISC_NEED_MATRIXFIXED2D GFXOFF |
||||
//#define GMISC_NEED_HITTEST_POLY GFXOFF
|
||||
@ -1,177 +0,0 @@ |
||||
/* Copyright 2017 Fred Sundvik
|
||||
* |
||||
* This program is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, either version 2 of the License, or |
||||
* (at your option) any later version. |
||||
* |
||||
* This program is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
|
||||
#if defined(VISUALIZER_ENABLE) |
||||
|
||||
# include "default_animations.h" |
||||
# include "visualizer.h" |
||||
# ifdef LCD_ENABLE |
||||
# include "lcd_keyframes.h" |
||||
# endif |
||||
# ifdef LCD_BACKLIGHT_ENABLE |
||||
# include "lcd_backlight_keyframes.h" |
||||
# endif |
||||
|
||||
# ifdef BACKLIGHT_ENABLE |
||||
# include "led_backlight_keyframes.h" |
||||
# endif |
||||
|
||||
# include "visualizer_keyframes.h" |
||||
|
||||
# if defined(LCD_ENABLE) || defined(LCD_BACKLIGHT_ENABLE) || defined(BACKLIGHT_ENABLE) |
||||
|
||||
static bool keyframe_enable(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
# ifdef LCD_ENABLE |
||||
lcd_keyframe_enable(animation, state); |
||||
# endif |
||||
# ifdef LCD_BACKLIGHT_ENABLE |
||||
lcd_backlight_keyframe_enable(animation, state); |
||||
# endif |
||||
# ifdef BACKLIGHT_ENABLE |
||||
led_backlight_keyframe_enable(animation, state); |
||||
# endif |
||||
return false; |
||||
} |
||||
|
||||
static bool keyframe_disable(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
# ifdef LCD_ENABLE |
||||
lcd_keyframe_disable(animation, state); |
||||
# endif |
||||
# ifdef LCD_BACKLIGHT_ENABLE |
||||
lcd_backlight_keyframe_disable(animation, state); |
||||
# endif |
||||
# ifdef BACKLIGHT_ENABLE |
||||
led_backlight_keyframe_disable(animation, state); |
||||
# endif |
||||
return false; |
||||
} |
||||
|
||||
static bool keyframe_fade_in(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
bool ret = false; |
||||
# ifdef LCD_BACKLIGHT_ENABLE |
||||
ret |= lcd_backlight_keyframe_animate_color(animation, state); |
||||
# endif |
||||
# ifdef BACKLIGHT_ENABLE |
||||
ret |= led_backlight_keyframe_fade_in_all(animation, state); |
||||
# endif |
||||
return ret; |
||||
} |
||||
|
||||
static bool keyframe_fade_out(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
bool ret = false; |
||||
# ifdef LCD_BACKLIGHT_ENABLE |
||||
ret |= lcd_backlight_keyframe_animate_color(animation, state); |
||||
# endif |
||||
# ifdef BACKLIGHT_ENABLE |
||||
ret |= led_backlight_keyframe_fade_out_all(animation, state); |
||||
# endif |
||||
return ret; |
||||
} |
||||
|
||||
// Don't worry, if the startup animation is long, you can use the keyboard like normal
|
||||
// during that time
|
||||
keyframe_animation_t default_startup_animation = { |
||||
# if LCD_ENABLE |
||||
.num_frames = 3, |
||||
# else |
||||
.num_frames = 2, |
||||
# endif |
||||
.loop = false, |
||||
.frame_lengths = {0, |
||||
# if LCD_ENABLE |
||||
0, |
||||
# endif |
||||
gfxMillisecondsToTicks(5000)}, |
||||
.frame_functions = |
||||
{ |
||||
keyframe_enable, |
||||
# if LCD_ENABLE |
||||
lcd_keyframe_draw_logo, |
||||
# endif |
||||
keyframe_fade_in, |
||||
}, |
||||
}; |
||||
|
||||
keyframe_animation_t default_suspend_animation = { |
||||
# if LCD_ENABLE |
||||
.num_frames = 3, |
||||
# else |
||||
.num_frames = 2, |
||||
# endif |
||||
.loop = false, |
||||
.frame_lengths = |
||||
{ |
||||
# if LCD_ENABLE |
||||
0, |
||||
# endif |
||||
gfxMillisecondsToTicks(1000), 0}, |
||||
.frame_functions = |
||||
{ |
||||
# if LCD_ENABLE |
||||
lcd_keyframe_display_layer_text, |
||||
# endif |
||||
keyframe_fade_out, |
||||
keyframe_disable, |
||||
}, |
||||
}; |
||||
# endif |
||||
|
||||
# if defined(BACKLIGHT_ENABLE) |
||||
# define CROSSFADE_TIME 1000 |
||||
# define GRADIENT_TIME 3000 |
||||
|
||||
keyframe_animation_t led_test_animation = { |
||||
.num_frames = 14, |
||||
.loop = true, |
||||
.frame_lengths = |
||||
{ |
||||
gfxMillisecondsToTicks(1000), // fade in
|
||||
gfxMillisecondsToTicks(1000), // no op (leds on)
|
||||
gfxMillisecondsToTicks(1000), // fade out
|
||||
gfxMillisecondsToTicks(CROSSFADE_TIME), // crossfade
|
||||
gfxMillisecondsToTicks(GRADIENT_TIME), // left to rigt (outside in)
|
||||
gfxMillisecondsToTicks(CROSSFADE_TIME), // crossfade
|
||||
gfxMillisecondsToTicks(GRADIENT_TIME), // top_to_bottom
|
||||
0, // mirror leds
|
||||
gfxMillisecondsToTicks(CROSSFADE_TIME), // crossfade
|
||||
gfxMillisecondsToTicks(GRADIENT_TIME), // left_to_right (mirrored, so inside out)
|
||||
gfxMillisecondsToTicks(CROSSFADE_TIME), // crossfade
|
||||
gfxMillisecondsToTicks(GRADIENT_TIME), // top_to_bottom
|
||||
0, // normal leds
|
||||
gfxMillisecondsToTicks(CROSSFADE_TIME), // crossfade
|
||||
|
||||
}, |
||||
.frame_functions = |
||||
{ |
||||
led_backlight_keyframe_fade_in_all, |
||||
keyframe_no_operation, |
||||
led_backlight_keyframe_fade_out_all, |
||||
led_backlight_keyframe_crossfade, |
||||
led_backlight_keyframe_left_to_right_gradient, |
||||
led_backlight_keyframe_crossfade, |
||||
led_backlight_keyframe_top_to_bottom_gradient, |
||||
led_backlight_keyframe_mirror_orientation, |
||||
led_backlight_keyframe_crossfade, |
||||
led_backlight_keyframe_left_to_right_gradient, |
||||
led_backlight_keyframe_crossfade, |
||||
led_backlight_keyframe_top_to_bottom_gradient, |
||||
led_backlight_keyframe_normal_orientation, |
||||
led_backlight_keyframe_crossfade, |
||||
}, |
||||
}; |
||||
# endif |
||||
|
||||
#endif |
||||
@ -1,27 +0,0 @@ |
||||
/* Copyright 2017 Fred Sundvik
|
||||
* |
||||
* This program is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, either version 2 of the License, or |
||||
* (at your option) any later version. |
||||
* |
||||
* This program is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
|
||||
#pragma once |
||||
|
||||
#include "visualizer.h" |
||||
|
||||
// You can use these default animations, but of course you can also write your own custom ones instead
|
||||
extern keyframe_animation_t default_startup_animation; |
||||
extern keyframe_animation_t default_suspend_animation; |
||||
|
||||
// An animation for testing and demonstrating the led support, should probably not be used for real world
|
||||
// cases
|
||||
extern keyframe_animation_t led_test_animation; |
||||
@ -1,87 +0,0 @@ |
||||
/*
|
||||
The MIT License (MIT) |
||||
|
||||
Copyright (c) 2016 Fred Sundvik |
||||
|
||||
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. |
||||
*/ |
||||
|
||||
#include "lcd_backlight.h" |
||||
#include <math.h> |
||||
|
||||
static uint8_t current_hue = 0; |
||||
static uint8_t current_saturation = 0; |
||||
static uint8_t current_intensity = 0; |
||||
static uint8_t current_brightness = 0; |
||||
|
||||
void lcd_backlight_init(void) { |
||||
lcd_backlight_hal_init(); |
||||
lcd_backlight_color(current_hue, current_saturation, current_intensity); |
||||
} |
||||
|
||||
// This code is based on Brian Neltner's blogpost and example code
|
||||
// "Why every LED light should be using HSI colorspace".
|
||||
// http://blog.saikoled.com/post/43693602826/why-every-led-light-should-be-using-hsi
|
||||
static void hsi_to_rgb(float h, float s, float i, uint16_t* r_out, uint16_t* g_out, uint16_t* b_out) { |
||||
unsigned int r, g, b; |
||||
h = fmodf(h, 360.0f); // cycle h around to 0-360 degrees
|
||||
h = 3.14159f * h / 180.0f; // Convert to radians.
|
||||
s = s > 0.0f ? (s < 1.0f ? s : 1.0f) : 0.0f; // clamp s and i to interval [0,1]
|
||||
i = i > 0.0f ? (i < 1.0f ? i : 1.0f) : 0.0f; |
||||
|
||||
// Math! Thanks in part to Kyle Miller.
|
||||
if (h < 2.09439f) { |
||||
r = 65535.0f * i / 3.0f * (1.0f + s * cos(h) / cosf(1.047196667f - h)); |
||||
g = 65535.0f * i / 3.0f * (1.0f + s * (1.0f - cosf(h) / cos(1.047196667f - h))); |
||||
b = 65535.0f * i / 3.0f * (1.0f - s); |
||||
} else if (h < 4.188787) { |
||||
h = h - 2.09439; |
||||
g = 65535.0f * i / 3.0f * (1.0f + s * cosf(h) / cosf(1.047196667f - h)); |
||||
b = 65535.0f * i / 3.0f * (1.0f + s * (1.0f - cosf(h) / cosf(1.047196667f - h))); |
||||
r = 65535.0f * i / 3.0f * (1.0f - s); |
||||
} else { |
||||
h = h - 4.188787; |
||||
b = 65535.0f * i / 3.0f * (1.0f + s * cosf(h) / cosf(1.047196667f - h)); |
||||
r = 65535.0f * i / 3.0f * (1.0f + s * (1.0f - cosf(h) / cosf(1.047196667f - h))); |
||||
g = 65535.0f * i / 3.0f * (1.0f - s); |
||||
} |
||||
*r_out = r > 65535 ? 65535 : r; |
||||
*g_out = g > 65535 ? 65535 : g; |
||||
*b_out = b > 65535 ? 65535 : b; |
||||
} |
||||
|
||||
void lcd_backlight_color(uint8_t hue, uint8_t saturation, uint8_t intensity) { |
||||
uint16_t r, g, b; |
||||
float hue_f = 360.0f * (float)hue / 255.0f; |
||||
float saturation_f = (float)saturation / 255.0f; |
||||
float intensity_f = (float)intensity / 255.0f; |
||||
intensity_f *= (float)current_brightness / 255.0f; |
||||
hsi_to_rgb(hue_f, saturation_f, intensity_f, &r, &g, &b); |
||||
current_hue = hue; |
||||
current_saturation = saturation; |
||||
current_intensity = intensity; |
||||
lcd_backlight_hal_color(r, g, b); |
||||
} |
||||
|
||||
void lcd_backlight_brightness(uint8_t b) { |
||||
current_brightness = b; |
||||
lcd_backlight_color(current_hue, current_saturation, current_intensity); |
||||
} |
||||
|
||||
uint8_t lcd_get_backlight_brightness(void) { return current_brightness; } |
||||
@ -1,43 +0,0 @@ |
||||
/*
|
||||
The MIT License (MIT) |
||||
|
||||
Copyright (c) 2016 Fred Sundvik |
||||
|
||||
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. |
||||
*/ |
||||
|
||||
#pragma once |
||||
|
||||
#include <stdint.h> |
||||
|
||||
// Helper macros for storing hue, staturation and intensity as unsigned integers
|
||||
#define LCD_COLOR(hue, saturation, intensity) (hue << 16 | saturation << 8 | intensity) |
||||
#define LCD_HUE(color) ((color >> 16) & 0xFF) |
||||
#define LCD_SAT(color) ((color >> 8) & 0xFF) |
||||
#define LCD_INT(color) (color & 0xFF) |
||||
|
||||
static inline uint32_t change_lcd_color_intensity(uint32_t color, uint8_t new_intensity) { return (color & 0xFFFFFF00) | new_intensity; } |
||||
|
||||
void lcd_backlight_init(void); |
||||
void lcd_backlight_color(uint8_t hue, uint8_t saturation, uint8_t intensity); |
||||
void lcd_backlight_brightness(uint8_t b); |
||||
uint8_t lcd_get_backlight_brightness(void); |
||||
|
||||
void lcd_backlight_hal_init(void); |
||||
void lcd_backlight_hal_color(uint16_t r, uint16_t g, uint16_t b); |
||||
@ -1,69 +0,0 @@ |
||||
/* Copyright 2017 Fred Sundvik
|
||||
* |
||||
* This program is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, either version 2 of the License, or |
||||
* (at your option) any later version. |
||||
* |
||||
* This program is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
|
||||
#include "lcd_backlight_keyframes.h" |
||||
|
||||
bool lcd_backlight_keyframe_animate_color(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
int frame_length = animation->frame_lengths[animation->current_frame]; |
||||
int current_pos = frame_length - animation->time_left_in_frame; |
||||
uint8_t t_h = LCD_HUE(state->target_lcd_color); |
||||
uint8_t t_s = LCD_SAT(state->target_lcd_color); |
||||
uint8_t t_i = LCD_INT(state->target_lcd_color); |
||||
uint8_t p_h = LCD_HUE(state->prev_lcd_color); |
||||
uint8_t p_s = LCD_SAT(state->prev_lcd_color); |
||||
uint8_t p_i = LCD_INT(state->prev_lcd_color); |
||||
|
||||
uint8_t d_h1 = t_h - p_h; // Modulo arithmetic since we want to wrap around
|
||||
int d_h2 = t_h - p_h; |
||||
// Chose the shortest way around
|
||||
int d_h = abs(d_h2) < d_h1 ? d_h2 : d_h1; |
||||
int d_s = t_s - p_s; |
||||
int d_i = t_i - p_i; |
||||
|
||||
int hue = (d_h * current_pos) / frame_length; |
||||
int sat = (d_s * current_pos) / frame_length; |
||||
int intensity = (d_i * current_pos) / frame_length; |
||||
// dprintf("%X -> %X = %X\n", p_h, t_h, hue);
|
||||
hue += p_h; |
||||
sat += p_s; |
||||
intensity += p_i; |
||||
state->current_lcd_color = LCD_COLOR(hue, sat, intensity); |
||||
lcd_backlight_color(LCD_HUE(state->current_lcd_color), LCD_SAT(state->current_lcd_color), LCD_INT(state->current_lcd_color)); |
||||
|
||||
return true; |
||||
} |
||||
|
||||
bool lcd_backlight_keyframe_set_color(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
(void)animation; |
||||
state->prev_lcd_color = state->target_lcd_color; |
||||
state->current_lcd_color = state->target_lcd_color; |
||||
lcd_backlight_color(LCD_HUE(state->current_lcd_color), LCD_SAT(state->current_lcd_color), LCD_INT(state->current_lcd_color)); |
||||
return false; |
||||
} |
||||
|
||||
bool lcd_backlight_keyframe_disable(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
(void)animation; |
||||
(void)state; |
||||
lcd_backlight_hal_color(0, 0, 0); |
||||
return false; |
||||
} |
||||
|
||||
bool lcd_backlight_keyframe_enable(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
(void)animation; |
||||
(void)state; |
||||
lcd_backlight_color(LCD_HUE(state->current_lcd_color), LCD_SAT(state->current_lcd_color), LCD_INT(state->current_lcd_color)); |
||||
return false; |
||||
} |
||||
@ -1,27 +0,0 @@ |
||||
/* Copyright 2017 Fred Sundvik
|
||||
* |
||||
* This program is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, either version 2 of the License, or |
||||
* (at your option) any later version. |
||||
* |
||||
* This program is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
|
||||
#pragma once |
||||
|
||||
#include "visualizer.h" |
||||
|
||||
// Animates the LCD backlight color between the current color and the target color (of the state)
|
||||
bool lcd_backlight_keyframe_animate_color(keyframe_animation_t* animation, visualizer_state_t* state); |
||||
// Sets the backlight color to the target color
|
||||
bool lcd_backlight_keyframe_set_color(keyframe_animation_t* animation, visualizer_state_t* state); |
||||
|
||||
bool lcd_backlight_keyframe_disable(keyframe_animation_t* animation, visualizer_state_t* state); |
||||
bool lcd_backlight_keyframe_enable(keyframe_animation_t* animation, visualizer_state_t* state); |
||||
@ -1,184 +0,0 @@ |
||||
/* Copyright 2017 Fred Sundvik
|
||||
* |
||||
* This program is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, either version 2 of the License, or |
||||
* (at your option) any later version. |
||||
* |
||||
* This program is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
|
||||
#include "lcd_keyframes.h" |
||||
#include <string.h> |
||||
#include "action_util.h" |
||||
#include "led.h" |
||||
#include "resources/resources.h" |
||||
|
||||
bool lcd_keyframe_display_layer_text(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
(void)animation; |
||||
gdispClear(White); |
||||
gdispDrawString(0, 10, state->layer_text, state->font_dejavusansbold12, Black); |
||||
return false; |
||||
} |
||||
|
||||
static void format_layer_bitmap_string(uint16_t default_layer, uint16_t layer, char* buffer) { |
||||
for (int i = 0; i < 16; i++) { |
||||
uint32_t mask = (1u << i); |
||||
if (default_layer & mask) { |
||||
if (layer & mask) { |
||||
*buffer = 'B'; |
||||
} else { |
||||
*buffer = 'D'; |
||||
} |
||||
} else if (layer & mask) { |
||||
*buffer = '1'; |
||||
} else { |
||||
*buffer = '0'; |
||||
} |
||||
++buffer; |
||||
|
||||
if (i == 3 || i == 7 || i == 11) { |
||||
*buffer = ' '; |
||||
++buffer; |
||||
} |
||||
} |
||||
*buffer = 0; |
||||
} |
||||
|
||||
bool lcd_keyframe_display_layer_bitmap(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
(void)animation; |
||||
const char* layer_help = "1=On D=Default B=Both"; |
||||
char layer_buffer[16 + 4]; // 3 spaces and one null terminator
|
||||
gdispClear(White); |
||||
gdispDrawString(0, 0, layer_help, state->font_fixed5x8, Black); |
||||
format_layer_bitmap_string(state->status.default_layer, state->status.layer, layer_buffer); |
||||
gdispDrawString(0, 10, layer_buffer, state->font_fixed5x8, Black); |
||||
format_layer_bitmap_string(state->status.default_layer >> 16, state->status.layer >> 16, layer_buffer); |
||||
gdispDrawString(0, 20, layer_buffer, state->font_fixed5x8, Black); |
||||
return false; |
||||
} |
||||
|
||||
static void format_mods_bitmap_string(uint8_t mods, char* buffer) { |
||||
*buffer = ' '; |
||||
++buffer; |
||||
|
||||
for (int i = 0; i < 8; i++) { |
||||
uint32_t mask = (1u << i); |
||||
if (mods & mask) { |
||||
*buffer = '1'; |
||||
} else { |
||||
*buffer = '0'; |
||||
} |
||||
++buffer; |
||||
|
||||
if (i == 3) { |
||||
*buffer = ' '; |
||||
++buffer; |
||||
} |
||||
} |
||||
*buffer = 0; |
||||
} |
||||
|
||||
bool lcd_keyframe_display_mods_bitmap(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
(void)animation; |
||||
|
||||
const char* title = "Modifier states"; |
||||
const char* mods_header = " CSAG CSAG "; |
||||
char status_buffer[12]; |
||||
|
||||
gdispClear(White); |
||||
gdispDrawString(0, 0, title, state->font_fixed5x8, Black); |
||||
gdispDrawString(0, 10, mods_header, state->font_fixed5x8, Black); |
||||
format_mods_bitmap_string(state->status.mods, status_buffer); |
||||
gdispDrawString(0, 20, status_buffer, state->font_fixed5x8, Black); |
||||
|
||||
return false; |
||||
} |
||||
|
||||
#define LED_STATE_STRING_SIZE sizeof("NUM CAPS SCRL COMP KANA") |
||||
|
||||
static void get_led_state_string(char* output, visualizer_state_t* state) { |
||||
uint8_t pos = 0; |
||||
|
||||
if (state->status.leds & (1u << USB_LED_NUM_LOCK)) { |
||||
memcpy(output + pos, "NUM ", 4); |
||||
pos += 4; |
||||
} |
||||
if (state->status.leds & (1u << USB_LED_CAPS_LOCK)) { |
||||
memcpy(output + pos, "CAPS ", 5); |
||||
pos += 5; |
||||
} |
||||
if (state->status.leds & (1u << USB_LED_SCROLL_LOCK)) { |
||||
memcpy(output + pos, "SCRL ", 5); |
||||
pos += 5; |
||||
} |
||||
if (state->status.leds & (1u << USB_LED_COMPOSE)) { |
||||
memcpy(output + pos, "COMP ", 5); |
||||
pos += 5; |
||||
} |
||||
if (state->status.leds & (1u << USB_LED_KANA)) { |
||||
memcpy(output + pos, "KANA", 4); |
||||
pos += 4; |
||||
} |
||||
output[pos] = 0; |
||||
} |
||||
|
||||
bool lcd_keyframe_display_led_states(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
(void)animation; |
||||
char output[LED_STATE_STRING_SIZE]; |
||||
get_led_state_string(output, state); |
||||
gdispClear(White); |
||||
gdispDrawString(0, 10, output, state->font_dejavusansbold12, Black); |
||||
return false; |
||||
} |
||||
|
||||
bool lcd_keyframe_display_layer_and_led_states(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
(void)animation; |
||||
gdispClear(White); |
||||
uint8_t y = 10; |
||||
if (state->status.leds) { |
||||
char output[LED_STATE_STRING_SIZE]; |
||||
get_led_state_string(output, state); |
||||
gdispDrawString(0, 1, output, state->font_dejavusansbold12, Black); |
||||
y = 17; |
||||
} |
||||
gdispDrawString(0, y, state->layer_text, state->font_dejavusansbold12, Black); |
||||
return false; |
||||
} |
||||
|
||||
bool lcd_keyframe_draw_logo(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
(void)state; |
||||
(void)animation; |
||||
// Read the uGFX documentation for information how to use the displays
|
||||
// http://wiki.ugfx.org/index.php/Main_Page
|
||||
gdispClear(Black); |
||||
|
||||
// You can use static variables for things that can't be found in the animation
|
||||
// or state structs, here we use the image
|
||||
|
||||
// gdispGBlitArea is a tricky function to use since it supports blitting part of the image
|
||||
// if you have full screen image, then just use LCD_WIDTH and LCD_HEIGHT for both source and target dimensions
|
||||
gdispGBlitArea(GDISP, 0, 0, 128, 32, 0, 0, LCD_WIDTH, (pixel_t*)resource_lcd_logo); |
||||
|
||||
return false; |
||||
} |
||||
|
||||
bool lcd_keyframe_disable(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
(void)animation; |
||||
(void)state; |
||||
gdispSetPowerMode(powerOff); |
||||
return false; |
||||
} |
||||
|
||||
bool lcd_keyframe_enable(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
(void)animation; |
||||
(void)state; |
||||
gdispSetPowerMode(powerOn); |
||||
return false; |
||||
} |
||||
@ -1,35 +0,0 @@ |
||||
/* Copyright 2017 Fred Sundvik
|
||||
* |
||||
* This program is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, either version 2 of the License, or |
||||
* (at your option) any later version. |
||||
* |
||||
* This program is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
|
||||
#pragma once |
||||
|
||||
#include "visualizer.h" |
||||
|
||||
// Displays the layer text centered vertically on the screen
|
||||
bool lcd_keyframe_display_layer_text(keyframe_animation_t* animation, visualizer_state_t* state); |
||||
// Displays a bitmap (0/1) of all the currently active layers
|
||||
bool lcd_keyframe_display_layer_bitmap(keyframe_animation_t* animation, visualizer_state_t* state); |
||||
// Displays a bitmap (0/1) of all the currently active mods
|
||||
bool lcd_keyframe_display_mods_bitmap(keyframe_animation_t* animation, visualizer_state_t* state); |
||||
// Displays the keyboard led states (CAPS (Caps lock), NUM (Num lock), SCRL (Scroll lock), COMP (Compose), KANA)
|
||||
bool lcd_keyframe_display_led_states(keyframe_animation_t* animation, visualizer_state_t* state); |
||||
// Displays both the layer text and the led states
|
||||
bool lcd_keyframe_display_layer_and_led_states(keyframe_animation_t* animation, visualizer_state_t* state); |
||||
// Displays the QMK logo on the LCD screen
|
||||
bool lcd_keyframe_draw_logo(keyframe_animation_t* animation, visualizer_state_t* state); |
||||
|
||||
bool lcd_keyframe_disable(keyframe_animation_t* animation, visualizer_state_t* state); |
||||
bool lcd_keyframe_enable(keyframe_animation_t* animation, visualizer_state_t* state); |
||||
@ -1,143 +0,0 @@ |
||||
/*
|
||||
The MIT License (MIT) |
||||
|
||||
Copyright (c) 2016 Fred Sundvik |
||||
|
||||
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. |
||||
*/ |
||||
#include "gfx.h" |
||||
#include <math.h> |
||||
#include "led_backlight_keyframes.h" |
||||
|
||||
static uint8_t fade_led_color(keyframe_animation_t* animation, int from, int to) { |
||||
int frame_length = animation->frame_lengths[animation->current_frame]; |
||||
int current_pos = frame_length - animation->time_left_in_frame; |
||||
int delta = to - from; |
||||
int luma = (delta * current_pos) / frame_length; |
||||
luma += from; |
||||
return luma; |
||||
} |
||||
|
||||
static void keyframe_fade_all_leds_from_to(keyframe_animation_t* animation, uint8_t from, uint8_t to) { |
||||
uint8_t luma = fade_led_color(animation, from, to); |
||||
color_t color = LUMA2COLOR(luma); |
||||
gdispGClear(LED_DISPLAY, color); |
||||
} |
||||
|
||||
// TODO: Should be customizable per keyboard
|
||||
#define NUM_ROWS LED_HEIGHT |
||||
#define NUM_COLS LED_WIDTH |
||||
|
||||
static uint8_t crossfade_start_frame[NUM_ROWS][NUM_COLS]; |
||||
static uint8_t crossfade_end_frame[NUM_ROWS][NUM_COLS]; |
||||
|
||||
static uint8_t compute_gradient_color(float t, float index, float num) { |
||||
const float two_pi = M_PI * 2.0f; |
||||
float normalized_index = (1.0f - index / (num - 1.0f)) * two_pi; |
||||
float x = t * two_pi + normalized_index; |
||||
float v = 0.5 * (cosf(x) + 1.0f); |
||||
return (uint8_t)(255.0f * v); |
||||
} |
||||
|
||||
bool led_backlight_keyframe_fade_in_all(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
(void)state; |
||||
keyframe_fade_all_leds_from_to(animation, 0, 255); |
||||
return true; |
||||
} |
||||
|
||||
bool led_backlight_keyframe_fade_out_all(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
(void)state; |
||||
keyframe_fade_all_leds_from_to(animation, 255, 0); |
||||
return true; |
||||
} |
||||
|
||||
bool led_backlight_keyframe_left_to_right_gradient(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
(void)state; |
||||
float frame_length = animation->frame_lengths[animation->current_frame]; |
||||
float current_pos = frame_length - animation->time_left_in_frame; |
||||
float t = current_pos / frame_length; |
||||
for (int i = 0; i < NUM_COLS; i++) { |
||||
uint8_t color = compute_gradient_color(t, i, NUM_COLS); |
||||
gdispGDrawLine(LED_DISPLAY, i, 0, i, NUM_ROWS - 1, LUMA2COLOR(color)); |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
bool led_backlight_keyframe_top_to_bottom_gradient(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
(void)state; |
||||
float frame_length = animation->frame_lengths[animation->current_frame]; |
||||
float current_pos = frame_length - animation->time_left_in_frame; |
||||
float t = current_pos / frame_length; |
||||
for (int i = 0; i < NUM_ROWS; i++) { |
||||
uint8_t color = compute_gradient_color(t, i, NUM_ROWS); |
||||
gdispGDrawLine(LED_DISPLAY, 0, i, NUM_COLS - 1, i, LUMA2COLOR(color)); |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
static void copy_current_led_state(uint8_t* dest) { |
||||
for (int i = 0; i < NUM_ROWS; i++) { |
||||
for (int j = 0; j < NUM_COLS; j++) { |
||||
dest[i * NUM_COLS + j] = gdispGGetPixelColor(LED_DISPLAY, j, i); |
||||
} |
||||
} |
||||
} |
||||
bool led_backlight_keyframe_crossfade(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
(void)state; |
||||
if (animation->first_update_of_frame) { |
||||
copy_current_led_state(&crossfade_start_frame[0][0]); |
||||
run_next_keyframe(animation, state); |
||||
copy_current_led_state(&crossfade_end_frame[0][0]); |
||||
} |
||||
for (int i = 0; i < NUM_ROWS; i++) { |
||||
for (int j = 0; j < NUM_COLS; j++) { |
||||
color_t color = LUMA2COLOR(fade_led_color(animation, crossfade_start_frame[i][j], crossfade_end_frame[i][j])); |
||||
gdispGDrawPixel(LED_DISPLAY, j, i, color); |
||||
} |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
bool led_backlight_keyframe_mirror_orientation(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
(void)state; |
||||
(void)animation; |
||||
gdispGSetOrientation(LED_DISPLAY, GDISP_ROTATE_180); |
||||
return false; |
||||
} |
||||
|
||||
bool led_backlight_keyframe_normal_orientation(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
(void)state; |
||||
(void)animation; |
||||
gdispGSetOrientation(LED_DISPLAY, GDISP_ROTATE_0); |
||||
return false; |
||||
} |
||||
|
||||
bool led_backlight_keyframe_disable(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
(void)state; |
||||
(void)animation; |
||||
gdispGSetPowerMode(LED_DISPLAY, powerOff); |
||||
return false; |
||||
} |
||||
|
||||
bool led_backlight_keyframe_enable(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
(void)state; |
||||
(void)animation; |
||||
gdispGSetPowerMode(LED_DISPLAY, powerOn); |
||||
return false; |
||||
} |
||||
@ -1,40 +0,0 @@ |
||||
/*
|
||||
The MIT License (MIT) |
||||
|
||||
Copyright (c) 2016 Fred Sundvik |
||||
|
||||
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. |
||||
*/ |
||||
|
||||
#pragma once |
||||
|
||||
#include "visualizer.h" |
||||
|
||||
bool led_backlight_keyframe_fade_in_all(keyframe_animation_t* animation, visualizer_state_t* state); |
||||
bool led_backlight_keyframe_fade_out_all(keyframe_animation_t* animation, visualizer_state_t* state); |
||||
bool led_backlight_keyframe_left_to_right_gradient(keyframe_animation_t* animation, visualizer_state_t* state); |
||||
bool led_backlight_keyframe_top_to_bottom_gradient(keyframe_animation_t* animation, visualizer_state_t* state); |
||||
bool led_backlight_keyframe_crossfade(keyframe_animation_t* animation, visualizer_state_t* state); |
||||
bool led_backlight_keyframe_mirror_orientation(keyframe_animation_t* animation, visualizer_state_t* state); |
||||
bool led_backlight_keyframe_normal_orientation(keyframe_animation_t* animation, visualizer_state_t* state); |
||||
|
||||
bool led_backlight_keyframe_disable(keyframe_animation_t* animation, visualizer_state_t* state); |
||||
bool led_backlight_keyframe_enable(keyframe_animation_t* animation, visualizer_state_t* state); |
||||
|
||||
extern keyframe_animation_t led_test_animation; |
||||
@ -1,18 +0,0 @@ |
||||
# A visualization library for the TMK keyboard firmware |
||||
|
||||
This library is designed to work together with the [TMK keyboard firmware](https://github.com/tmk/tmk_keyboard). Currently it only works for [Chibios](http://www.chibios.org/) |
||||
flavors, but it would be possible to add support for other configurations as well. The LCD display functionality is provided by the [uGFX library](https://ugfx.io/). |
||||
|
||||
## To use this library as a user |
||||
You can and should modify the visualizer\_user.c file. Check the comments in the file for more information. |
||||
|
||||
## To add this library to custom keyboard projects |
||||
|
||||
1. Add tmk_visualizer as a submodule to your project |
||||
1. Set VISUALIZER_DIR in the main keyboard project makefile to point to the submodule |
||||
1. Define LCD\_ENABLE and/or LCD\_BACKLIGHT\_ENABLE, to enable support |
||||
1. Include the visualizer.mk make file |
||||
1. Copy the files in the example\_integration folder to your keyboard project |
||||
1. All other files than the callback.c file are included automatically, so you will need to add callback.c to your makefile manually. If you already have a similar file in your project, you can just copy the functions instead of the whole file. |
||||
1. Edit the files to match your hardware. You might might want to read the Chibios and UGfx documentation, for more information. |
||||
1. If you enable LCD support you might also have to write a custom uGFX display driver, check the uGFX documentation for that. You probably also want to enable SPI support in your Chibios configuration. |
||||
@ -1,45 +0,0 @@ |
||||
/* Copyright 2017 Fred Sundvik
|
||||
* |
||||
* This program is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, either version 2 of the License, or |
||||
* (at your option) any later version. |
||||
* |
||||
* This program is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
|
||||
#include "resources.h" |
||||
|
||||
// clang-format off
|
||||
|
||||
// To generate an image array like this
|
||||
// Ensure the image is 128 x 32 or smaller
|
||||
// Convert the bitmap to a C array using a program like http://www.riuson.com/lcd-image-converter/
|
||||
// Ensure the the conversion process produces a monochrome format array - 1 bit/pixel, left to right, top to bottom
|
||||
// Update array in the source code with the C array produced by the conversion program
|
||||
|
||||
// The image below is generated from lcd_logo.png
|
||||
__attribute__((weak)) const uint8_t resource_lcd_logo[512] = { |
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
||||
0x00, 0x02, 0x92, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x92, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
||||
0x00, 0x02, 0x92, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
||||
0x00, 0x1F, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
||||
0x00, 0xFE, 0xEE, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E, 0xEE, 0xF0, 0x01, 0xC6, 0x0D, 0x8C, 0x1F, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
||||
0x00, 0xFE, 0xEE, 0xFE, 0x03, 0xE7, 0x1D, 0x9C, 0x1F, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E, 0xEE, 0xF0, 0x06, 0x37, 0x1D, 0xB8, 0x18, 0x0B, 0x59, 0xC8, 0x09, 0xE5, 0x9E, 0x00, |
||||
0x00, 0x1E, 0xEE, 0xF0, 0x06, 0x37, 0xBD, 0xF0, 0x18, 0x6F, 0x7F, 0xEC, 0x9B, 0x37, 0xB3, 0x00, 0x00, 0xFE, 0xEE, 0xFE, 0x06, 0x37, 0xBD, 0xE0, 0x1F, 0x6C, 0x66, 0x6D, 0xD8, 0x36, 0x33, 0x00, |
||||
0x00, 0x1E, 0xEE, 0xF0, 0x06, 0x36, 0xED, 0xF0, 0x1F, 0x6C, 0x66, 0x6D, 0x59, 0xF6, 0x3E, 0x00, 0x00, 0x1F, 0x6D, 0xF0, 0x06, 0x36, 0xED, 0xB8, 0x18, 0x6C, 0x66, 0x67, 0x73, 0x36, 0x30, 0x00, |
||||
0x00, 0xFF, 0x83, 0xFE, 0x03, 0xE6, 0x4D, 0x9C, 0x18, 0x6C, 0x66, 0x67, 0x73, 0x36, 0x1F, 0x00, 0x00, 0x1F, 0xEF, 0xF0, 0x01, 0xC6, 0x0D, 0x8C, 0x18, 0x6C, 0x66, 0x62, 0x21, 0xD6, 0x0E, 0x00, |
||||
0x00, 0xFF, 0xEF, 0xFE, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xF0, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
||||
0x00, 0x1F, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
||||
0x00, 0x02, 0x92, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x92, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
||||
0x00, 0x02, 0x92, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 |
||||
}; |
||||
|
Before Width: | Height: | Size: 271 B |
@ -1,23 +0,0 @@ |
||||
/* Copyright 2017 Fred Sundvik
|
||||
* |
||||
* This program is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, either version 2 of the License, or |
||||
* (at your option) any later version. |
||||
* |
||||
* This program is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
|
||||
#pragma once |
||||
|
||||
#include <stdint.h> |
||||
|
||||
#ifdef LCD_ENABLE |
||||
extern const uint8_t resource_lcd_logo[]; |
||||
#endif |
||||
@ -1,483 +0,0 @@ |
||||
/*
|
||||
The MIT License (MIT) |
||||
|
||||
Copyright (c) 2016 Fred Sundvik |
||||
|
||||
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. |
||||
*/ |
||||
|
||||
#include "config.h" |
||||
#include "visualizer.h" |
||||
#include <string.h> |
||||
#ifdef PROTOCOL_CHIBIOS |
||||
# include <ch.h> |
||||
#endif |
||||
|
||||
#include "gfx.h" |
||||
|
||||
#ifdef LCD_BACKLIGHT_ENABLE |
||||
# include "lcd_backlight.h" |
||||
#endif |
||||
|
||||
//#define DEBUG_VISUALIZER
|
||||
|
||||
#ifdef DEBUG_VISUALIZER |
||||
# include "debug.h" |
||||
#else |
||||
# include "nodebug.h" |
||||
#endif |
||||
|
||||
#ifdef SERIAL_LINK_ENABLE |
||||
# include "serial_link/protocol/transport.h" |
||||
# include "serial_link/system/serial_link.h" |
||||
#endif |
||||
|
||||
#include "action_util.h" |
||||
|
||||
// Define this in config.h
|
||||
#ifndef VISUALIZER_THREAD_PRIORITY |
||||
// The visualizer needs gfx thread priorities
|
||||
# define VISUALIZER_THREAD_PRIORITY (NORMAL_PRIORITY - 2) |
||||
#endif |
||||
|
||||
static visualizer_keyboard_status_t current_status = {.layer = 0xFFFFFFFF, |
||||
.default_layer = 0xFFFFFFFF, |
||||
.leds = 0xFFFFFFFF, |
||||
#ifdef BACKLIGHT_ENABLE |
||||
.backlight_level = 0, |
||||
#endif |
||||
.mods = 0xFF, |
||||
.suspended = false, |
||||
#ifdef VISUALIZER_USER_DATA_SIZE |
||||
.user_data = {0} |
||||
#endif |
||||
}; |
||||
|
||||
static bool same_status(visualizer_keyboard_status_t* status1, visualizer_keyboard_status_t* status2) { |
||||
return status1->layer == status2->layer && status1->default_layer == status2->default_layer && status1->mods == status2->mods && status1->leds == status2->leds && status1->suspended == status2->suspended |
||||
#ifdef BACKLIGHT_ENABLE |
||||
&& status1->backlight_level == status2->backlight_level |
||||
#endif |
||||
#ifdef VISUALIZER_USER_DATA_SIZE |
||||
&& memcmp(status1->user_data, status2->user_data, VISUALIZER_USER_DATA_SIZE) == 0 |
||||
#endif |
||||
; |
||||
} |
||||
|
||||
static bool visualizer_enabled = false; |
||||
|
||||
#ifdef VISUALIZER_USER_DATA_SIZE |
||||
static uint8_t user_data[VISUALIZER_USER_DATA_SIZE]; |
||||
#endif |
||||
|
||||
#define MAX_SIMULTANEOUS_ANIMATIONS 4 |
||||
static keyframe_animation_t* animations[MAX_SIMULTANEOUS_ANIMATIONS] = {}; |
||||
|
||||
#ifdef SERIAL_LINK_ENABLE |
||||
MASTER_TO_ALL_SLAVES_OBJECT(current_status, visualizer_keyboard_status_t); |
||||
|
||||
static remote_object_t* remote_objects[] = { |
||||
REMOTE_OBJECT(current_status), |
||||
}; |
||||
|
||||
#endif |
||||
|
||||
GDisplay* LCD_DISPLAY = 0; |
||||
GDisplay* LED_DISPLAY = 0; |
||||
|
||||
#ifdef LCD_DISPLAY_NUMBER |
||||
__attribute__((weak)) GDisplay* get_lcd_display(void) { return gdispGetDisplay(LCD_DISPLAY_NUMBER); } |
||||
#endif |
||||
|
||||
#ifdef LED_DISPLAY_NUMBER |
||||
__attribute__((weak)) GDisplay* get_led_display(void) { return gdispGetDisplay(LED_DISPLAY_NUMBER); } |
||||
#endif |
||||
|
||||
void start_keyframe_animation(keyframe_animation_t* animation) { |
||||
animation->current_frame = -1; |
||||
animation->time_left_in_frame = 0; |
||||
animation->need_update = true; |
||||
int free_index = -1; |
||||
for (int i = 0; i < MAX_SIMULTANEOUS_ANIMATIONS; i++) { |
||||
if (animations[i] == animation) { |
||||
return; |
||||
} |
||||
if (free_index == -1 && animations[i] == NULL) { |
||||
free_index = i; |
||||
} |
||||
} |
||||
if (free_index != -1) { |
||||
animations[free_index] = animation; |
||||
} |
||||
} |
||||
|
||||
void stop_keyframe_animation(keyframe_animation_t* animation) { |
||||
animation->current_frame = animation->num_frames; |
||||
animation->time_left_in_frame = 0; |
||||
animation->need_update = true; |
||||
animation->first_update_of_frame = false; |
||||
animation->last_update_of_frame = false; |
||||
for (int i = 0; i < MAX_SIMULTANEOUS_ANIMATIONS; i++) { |
||||
if (animations[i] == animation) { |
||||
animations[i] = NULL; |
||||
return; |
||||
} |
||||
} |
||||
} |
||||
|
||||
void stop_all_keyframe_animations(void) { |
||||
for (int i = 0; i < MAX_SIMULTANEOUS_ANIMATIONS; i++) { |
||||
if (animations[i]) { |
||||
animations[i]->current_frame = animations[i]->num_frames; |
||||
animations[i]->time_left_in_frame = 0; |
||||
animations[i]->need_update = true; |
||||
animations[i]->first_update_of_frame = false; |
||||
animations[i]->last_update_of_frame = false; |
||||
animations[i] = NULL; |
||||
} |
||||
} |
||||
} |
||||
|
||||
static uint8_t get_num_running_animations(void) { |
||||
uint8_t count = 0; |
||||
for (int i = 0; i < MAX_SIMULTANEOUS_ANIMATIONS; i++) { |
||||
count += animations[i] ? 1 : 0; |
||||
} |
||||
return count; |
||||
} |
||||
|
||||
static bool update_keyframe_animation(keyframe_animation_t* animation, visualizer_state_t* state, systemticks_t delta, systemticks_t* sleep_time) { |
||||
// TODO: Clean up this messy code
|
||||
dprintf("Animation frame%d, left %d, delta %d\n", animation->current_frame, animation->time_left_in_frame, delta); |
||||
if (animation->current_frame == animation->num_frames) { |
||||
animation->need_update = false; |
||||
return false; |
||||
} |
||||
if (animation->current_frame == -1) { |
||||
animation->current_frame = 0; |
||||
animation->time_left_in_frame = animation->frame_lengths[0]; |
||||
animation->need_update = true; |
||||
animation->first_update_of_frame = true; |
||||
} else { |
||||
animation->time_left_in_frame -= delta; |
||||
while (animation->time_left_in_frame <= 0) { |
||||
int left = animation->time_left_in_frame; |
||||
if (animation->need_update) { |
||||
animation->time_left_in_frame = 0; |
||||
animation->last_update_of_frame = true; |
||||
(*animation->frame_functions[animation->current_frame])(animation, state); |
||||
animation->last_update_of_frame = false; |
||||
} |
||||
animation->current_frame++; |
||||
animation->need_update = true; |
||||
animation->first_update_of_frame = true; |
||||
if (animation->current_frame == animation->num_frames) { |
||||
if (animation->loop) { |
||||
animation->current_frame = 0; |
||||
} else { |
||||
stop_keyframe_animation(animation); |
||||
return false; |
||||
} |
||||
} |
||||
delta = -left; |
||||
animation->time_left_in_frame = animation->frame_lengths[animation->current_frame]; |
||||
animation->time_left_in_frame -= delta; |
||||
} |
||||
} |
||||
if (animation->need_update) { |
||||
animation->need_update = (*animation->frame_functions[animation->current_frame])(animation, state); |
||||
animation->first_update_of_frame = false; |
||||
} |
||||
|
||||
systemticks_t wanted_sleep = animation->need_update ? gfxMillisecondsToTicks(10) : (unsigned)animation->time_left_in_frame; |
||||
if (wanted_sleep < *sleep_time) { |
||||
*sleep_time = wanted_sleep; |
||||
} |
||||
|
||||
return true; |
||||
} |
||||
|
||||
void run_next_keyframe(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
int next_frame = animation->current_frame + 1; |
||||
if (next_frame == animation->num_frames) { |
||||
next_frame = 0; |
||||
} |
||||
keyframe_animation_t temp_animation = *animation; |
||||
temp_animation.current_frame = next_frame; |
||||
temp_animation.time_left_in_frame = animation->frame_lengths[next_frame]; |
||||
temp_animation.first_update_of_frame = true; |
||||
temp_animation.last_update_of_frame = false; |
||||
temp_animation.need_update = false; |
||||
visualizer_state_t temp_state = *state; |
||||
(*temp_animation.frame_functions[next_frame])(&temp_animation, &temp_state); |
||||
} |
||||
|
||||
// TODO: Optimize the stack size, this is probably way too big
|
||||
static DECLARE_THREAD_STACK(visualizerThreadStack, 1024); |
||||
static DECLARE_THREAD_FUNCTION(visualizerThread, arg) { |
||||
(void)arg; |
||||
|
||||
GListener event_listener; |
||||
geventListenerInit(&event_listener); |
||||
geventAttachSource(&event_listener, (GSourceHandle)¤t_status, 0); |
||||
|
||||
visualizer_keyboard_status_t initial_status = { |
||||
.default_layer = 0xFFFFFFFF, |
||||
.layer = 0xFFFFFFFF, |
||||
.mods = 0xFF, |
||||
.leds = 0xFFFFFFFF, |
||||
.suspended = false, |
||||
#ifdef BACKLIGHT_ENABLE |
||||
.backlight_level = 0, |
||||
#endif |
||||
#ifdef VISUALIZER_USER_DATA_SIZE |
||||
.user_data = {0}, |
||||
#endif |
||||
}; |
||||
|
||||
visualizer_state_t state = {.status = initial_status, |
||||
.current_lcd_color = 0, |
||||
#ifdef LCD_ENABLE |
||||
.font_fixed5x8 = gdispOpenFont("fixed_5x8"), |
||||
.font_dejavusansbold12 = gdispOpenFont("DejaVuSansBold12") |
||||
#endif |
||||
}; |
||||
initialize_user_visualizer(&state); |
||||
state.prev_lcd_color = state.current_lcd_color; |
||||
|
||||
#ifdef LCD_BACKLIGHT_ENABLE |
||||
lcd_backlight_color(LCD_HUE(state.current_lcd_color), LCD_SAT(state.current_lcd_color), LCD_INT(state.current_lcd_color)); |
||||
#endif |
||||
|
||||
systemticks_t sleep_time = TIME_INFINITE; |
||||
systemticks_t current_time = gfxSystemTicks(); |
||||
bool force_update = true; |
||||
|
||||
while (true) { |
||||
systemticks_t new_time = gfxSystemTicks(); |
||||
systemticks_t delta = new_time - current_time; |
||||
current_time = new_time; |
||||
bool enabled = visualizer_enabled; |
||||
if (force_update || !same_status(&state.status, ¤t_status)) { |
||||
force_update = false; |
||||
#if BACKLIGHT_ENABLE |
||||
if (current_status.backlight_level != state.status.backlight_level) { |
||||
if (current_status.backlight_level != 0) { |
||||
gdispGSetPowerMode(LED_DISPLAY, powerOn); |
||||
uint16_t percent = (uint16_t)current_status.backlight_level * 100 / BACKLIGHT_LEVELS; |
||||
gdispGSetBacklight(LED_DISPLAY, percent); |
||||
} else { |
||||
gdispGSetPowerMode(LED_DISPLAY, powerOff); |
||||
} |
||||
state.status.backlight_level = current_status.backlight_level; |
||||
} |
||||
#endif |
||||
if (visualizer_enabled) { |
||||
if (current_status.suspended) { |
||||
stop_all_keyframe_animations(); |
||||
visualizer_enabled = false; |
||||
state.status = current_status; |
||||
user_visualizer_suspend(&state); |
||||
} else { |
||||
visualizer_keyboard_status_t prev_status = state.status; |
||||
state.status = current_status; |
||||
update_user_visualizer_state(&state, &prev_status); |
||||
} |
||||
state.prev_lcd_color = state.current_lcd_color; |
||||
} |
||||
} |
||||
if (!enabled && state.status.suspended && current_status.suspended == false) { |
||||
// Setting the status to the initial status will force an update
|
||||
// when the visualizer is enabled again
|
||||
state.status = initial_status; |
||||
state.status.suspended = false; |
||||
stop_all_keyframe_animations(); |
||||
user_visualizer_resume(&state); |
||||
state.prev_lcd_color = state.current_lcd_color; |
||||
} |
||||
sleep_time = TIME_INFINITE; |
||||
for (int i = 0; i < MAX_SIMULTANEOUS_ANIMATIONS; i++) { |
||||
if (animations[i]) { |
||||
update_keyframe_animation(animations[i], &state, delta, &sleep_time); |
||||
} |
||||
} |
||||
#ifdef BACKLIGHT_ENABLE |
||||
gdispGFlush(LED_DISPLAY); |
||||
#endif |
||||
|
||||
#ifdef LCD_ENABLE |
||||
gdispGFlush(LCD_DISPLAY); |
||||
#endif |
||||
|
||||
#ifdef EMULATOR |
||||
draw_emulator(); |
||||
#endif |
||||
// Enable the visualizer when the startup or the suspend animation has finished
|
||||
if (!visualizer_enabled && state.status.suspended == false && get_num_running_animations() == 0) { |
||||
visualizer_enabled = true; |
||||
force_update = true; |
||||
sleep_time = 0; |
||||
} |
||||
|
||||
systemticks_t after_update = gfxSystemTicks(); |
||||
unsigned update_delta = after_update - current_time; |
||||
if (sleep_time != TIME_INFINITE) { |
||||
if (sleep_time > update_delta) { |
||||
sleep_time -= update_delta; |
||||
} else { |
||||
sleep_time = 0; |
||||
} |
||||
} |
||||
dprintf("Update took %d, last delta %d, sleep_time %d\n", update_delta, delta, sleep_time); |
||||
#ifdef PROTOCOL_CHIBIOS |
||||
// The gEventWait function really takes milliseconds, even if the documentation says ticks.
|
||||
// Unfortunately there's no generic ugfx conversion from system time to milliseconds,
|
||||
// so let's do it in a platform dependent way.
|
||||
|
||||
// On windows the system ticks is the same as milliseconds anyway
|
||||
if (sleep_time != TIME_INFINITE) { |
||||
sleep_time = TIME_I2MS(sleep_time); |
||||
} |
||||
#endif |
||||
geventEventWait(&event_listener, sleep_time); |
||||
} |
||||
#ifdef LCD_ENABLE |
||||
gdispCloseFont(state.font_fixed5x8); |
||||
gdispCloseFont(state.font_dejavusansbold12); |
||||
#endif |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
void visualizer_init(void) { |
||||
gfxInit(); |
||||
|
||||
#ifdef LCD_BACKLIGHT_ENABLE |
||||
lcd_backlight_init(); |
||||
#endif |
||||
|
||||
#ifdef SERIAL_LINK_ENABLE |
||||
add_remote_objects(remote_objects, sizeof(remote_objects) / sizeof(remote_object_t*)); |
||||
#endif |
||||
|
||||
#ifdef LCD_ENABLE |
||||
LCD_DISPLAY = get_lcd_display(); |
||||
#endif |
||||
|
||||
#ifdef BACKLIGHT_ENABLE |
||||
LED_DISPLAY = get_led_display(); |
||||
#endif |
||||
|
||||
// We are using a low priority thread, the idea is to have it run only
|
||||
// when the main thread is sleeping during the matrix scanning
|
||||
gfxThreadCreate(visualizerThreadStack, sizeof(visualizerThreadStack), VISUALIZER_THREAD_PRIORITY, visualizerThread, NULL); |
||||
} |
||||
|
||||
void update_status(bool changed) { |
||||
if (changed) { |
||||
GSourceListener* listener = geventGetSourceListener((GSourceHandle)¤t_status, NULL); |
||||
if (listener) { |
||||
geventSendEvent(listener); |
||||
} |
||||
} |
||||
#ifdef SERIAL_LINK_ENABLE |
||||
static systime_t last_update = 0; |
||||
systime_t current_update = chVTGetSystemTimeX(); |
||||
systime_t delta = current_update - last_update; |
||||
if (changed || delta > TIME_MS2I(10)) { |
||||
last_update = current_update; |
||||
visualizer_keyboard_status_t* r = begin_write_current_status(); |
||||
*r = current_status; |
||||
end_write_current_status(); |
||||
} |
||||
#endif |
||||
} |
||||
|
||||
uint8_t visualizer_get_mods() { |
||||
uint8_t mods = get_mods(); |
||||
|
||||
#ifndef NO_ACTION_ONESHOT |
||||
if (!has_oneshot_mods_timed_out()) { |
||||
mods |= get_oneshot_mods(); |
||||
} |
||||
#endif |
||||
return mods; |
||||
} |
||||
|
||||
#ifdef VISUALIZER_USER_DATA_SIZE |
||||
void visualizer_set_user_data(void* u) { memcpy(user_data, u, VISUALIZER_USER_DATA_SIZE); } |
||||
#endif |
||||
|
||||
void visualizer_update(layer_state_t default_state, layer_state_t state, uint8_t mods, uint32_t leds) { |
||||
// Note that there's a small race condition here, the thread could read
|
||||
// a state where one of these are set but not the other. But this should
|
||||
// not really matter as it will be fixed during the next loop step.
|
||||
// Alternatively a mutex could be used instead of the volatile variables
|
||||
|
||||
bool changed = false; |
||||
#ifdef SERIAL_LINK_ENABLE |
||||
if (is_serial_link_connected()) { |
||||
visualizer_keyboard_status_t* new_status = read_current_status(); |
||||
if (new_status) { |
||||
if (!same_status(¤t_status, new_status)) { |
||||
changed = true; |
||||
current_status = *new_status; |
||||
} |
||||
} |
||||
} else { |
||||
#else |
||||
{ |
||||
#endif |
||||
visualizer_keyboard_status_t new_status = { |
||||
.layer = state, |
||||
.default_layer = default_state, |
||||
.mods = mods, |
||||
.leds = leds, |
||||
#ifdef BACKLIGHT_ENABLE |
||||
.backlight_level = current_status.backlight_level, |
||||
#endif |
||||
.suspended = current_status.suspended, |
||||
}; |
||||
#ifdef VISUALIZER_USER_DATA_SIZE |
||||
memcpy(new_status.user_data, user_data, VISUALIZER_USER_DATA_SIZE); |
||||
#endif |
||||
if (!same_status(¤t_status, &new_status)) { |
||||
changed = true; |
||||
current_status = new_status; |
||||
} |
||||
} |
||||
update_status(changed); |
||||
} |
||||
|
||||
void visualizer_suspend(void) { |
||||
current_status.suspended = true; |
||||
update_status(true); |
||||
} |
||||
|
||||
void visualizer_resume(void) { |
||||
current_status.suspended = false; |
||||
update_status(true); |
||||
} |
||||
|
||||
#ifdef BACKLIGHT_ENABLE |
||||
void backlight_set(uint8_t level) { |
||||
current_status.backlight_level = level; |
||||
update_status(true); |
||||
} |
||||
#endif |
||||
@ -1,154 +0,0 @@ |
||||
/*
|
||||
The MIT License (MIT) |
||||
|
||||
Copyright (c) 2016 Fred Sundvik |
||||
|
||||
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. |
||||
*/ |
||||
|
||||
#pragma once |
||||
|
||||
#include <stdlib.h> |
||||
#include <stdint.h> |
||||
#include <stdbool.h> |
||||
|
||||
#include "config.h" |
||||
#include "gfx.h" |
||||
#include "action_layer.h" |
||||
|
||||
#ifdef LCD_BACKLIGHT_ENABLE |
||||
# include "lcd_backlight.h" |
||||
#endif |
||||
|
||||
#ifdef BACKLIGHT_ENABLE |
||||
# include "backlight.h" |
||||
#endif |
||||
|
||||
// use this function to merge both real_mods and oneshot_mods in a uint16_t
|
||||
uint8_t visualizer_get_mods(void); |
||||
|
||||
// This need to be called once at the start
|
||||
void visualizer_init(void); |
||||
// This should be called at every matrix scan
|
||||
void visualizer_update(layer_state_t default_state, layer_state_t state, uint8_t mods, uint32_t leds); |
||||
|
||||
// This should be called when the keyboard goes to suspend state
|
||||
void visualizer_suspend(void); |
||||
// This should be called when the keyboard wakes up from suspend state
|
||||
void visualizer_resume(void); |
||||
|
||||
// These functions are week, so they can be overridden by the keyboard
|
||||
// if needed
|
||||
GDisplay* get_lcd_display(void); |
||||
GDisplay* get_led_display(void); |
||||
|
||||
// For emulator builds, this function need to be implemented
|
||||
#ifdef EMULATOR |
||||
void draw_emulator(void); |
||||
#endif |
||||
|
||||
// If you need support for more than 16 keyframes per animation, you can change this
|
||||
#define MAX_VISUALIZER_KEY_FRAMES 16 |
||||
|
||||
struct keyframe_animation_t; |
||||
|
||||
typedef struct { |
||||
layer_state_t layer; |
||||
layer_state_t default_layer; |
||||
uint32_t leds; // See led.h for available statuses
|
||||
uint8_t mods; |
||||
bool suspended; |
||||
#ifdef BACKLIGHT_ENABLE |
||||
uint8_t backlight_level; |
||||
#endif |
||||
#ifdef VISUALIZER_USER_DATA_SIZE |
||||
uint8_t user_data[VISUALIZER_USER_DATA_SIZE]; |
||||
#endif |
||||
} visualizer_keyboard_status_t; |
||||
|
||||
// The state struct is used by the various keyframe functions
|
||||
// It's also used for setting the LCD color and layer text
|
||||
// from the user customized code
|
||||
typedef struct visualizer_state_t { |
||||
// The user code should primarily be modifying these
|
||||
uint32_t target_lcd_color; |
||||
const char* layer_text; |
||||
|
||||
// The user visualizer(and animation functions) can read these
|
||||
visualizer_keyboard_status_t status; |
||||
|
||||
// These are used by the animation functions
|
||||
uint32_t current_lcd_color; |
||||
uint32_t prev_lcd_color; |
||||
#ifdef LCD_ENABLE |
||||
gFont font_fixed5x8; |
||||
gFont font_dejavusansbold12; |
||||
#endif |
||||
} visualizer_state_t; |
||||
|
||||
// Any custom keyframe function should have this signature
|
||||
// return true to get continuous updates, otherwise you will only get one
|
||||
// update per frame
|
||||
typedef bool (*frame_func)(struct keyframe_animation_t*, visualizer_state_t*); |
||||
|
||||
// Represents a keyframe animation, so fields are internal to the system
|
||||
// while others are meant to be initialized by the user code
|
||||
typedef struct keyframe_animation_t { |
||||
// These should be initialized
|
||||
int num_frames; |
||||
bool loop; |
||||
int frame_lengths[MAX_VISUALIZER_KEY_FRAMES]; |
||||
frame_func frame_functions[MAX_VISUALIZER_KEY_FRAMES]; |
||||
|
||||
// Used internally by the system, and can also be read by
|
||||
// keyframe update functions
|
||||
int current_frame; |
||||
int time_left_in_frame; |
||||
bool first_update_of_frame; |
||||
bool last_update_of_frame; |
||||
bool need_update; |
||||
|
||||
} keyframe_animation_t; |
||||
|
||||
extern GDisplay* LCD_DISPLAY; |
||||
extern GDisplay* LED_DISPLAY; |
||||
|
||||
void start_keyframe_animation(keyframe_animation_t* animation); |
||||
void stop_keyframe_animation(keyframe_animation_t* animation); |
||||
// This runs the next keyframe, but does not update the animation state
|
||||
// Useful for crossfades for example
|
||||
void run_next_keyframe(keyframe_animation_t* animation, visualizer_state_t* state); |
||||
|
||||
// The master can set userdata which will be transferred to the slave
|
||||
#ifdef VISUALIZER_USER_DATA_SIZE |
||||
void visualizer_set_user_data(void* user_data); |
||||
#endif |
||||
|
||||
// These functions have to be implemented by the user
|
||||
// Called regularly each time the state has changed (but not every scan loop)
|
||||
void update_user_visualizer_state(visualizer_state_t* state, visualizer_keyboard_status_t* prev_status); |
||||
// Called when the computer goes to suspend, will also stop calling update_user_visualizer_state
|
||||
void user_visualizer_suspend(visualizer_state_t* state); |
||||
// You have to start at least one animation as a response to the following two functions
|
||||
// When the animation has finished the visualizer will resume normal operation and start calling the
|
||||
// update_user_visualizer_state again
|
||||
// Called when the keyboard boots up
|
||||
void initialize_user_visualizer(visualizer_state_t* state); |
||||
// Called when the computer resumes from a suspend
|
||||
void user_visualizer_resume(visualizer_state_t* state); |
||||
@ -1,123 +0,0 @@ |
||||
# The MIT License (MIT)
|
||||
#
|
||||
# Copyright (c) 2016 Fred Sundvik
|
||||
#
|
||||
# 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.
|
||||
|
||||
define ADD_DRIVER |
||||
$(1)_DRIVER:=$(strip $($(1)_DRIVER))
|
||||
$(1)_WIDTH:=$(strip $($(1)_WIDTH))
|
||||
$(1)_HEIGHT:=$(strip $($(1)_HEIGHT))
|
||||
ifeq ($($(1)_DRIVER),)
|
||||
$$(error $(1)_DRIVER is not defined)
|
||||
endif
|
||||
ifeq ($($(1)_WIDTH),)
|
||||
$$(error $(1)_WIDTH is not defined)
|
||||
endif
|
||||
ifeq ($($(1)_HEIGHT),)
|
||||
$$(error $(1)_HEIGHT is not defined)
|
||||
endif
|
||||
OPT_DEFS+=-D$(1)_WIDTH=$($(1)_WIDTH)
|
||||
OPT_DEFS+=-D$(1)_HEIGHT=$($(1)_HEIGHT)
|
||||
GFXDEFS+=-D$(1)_WIDTH=$($(1)_WIDTH)
|
||||
GFXDEFS+=-D$(1)_HEIGHT=$($(1)_HEIGHT)
|
||||
$(1)_DISPLAY_NUMBER:=$$(words $$(GDISP_DRIVER_LIST))
|
||||
OPT_DEFS+=-D$(1)_DISPLAY_NUMBER=$$($(1)_DISPLAY_NUMBER)
|
||||
include $(TOP_DIR)/drivers/ugfx/gdisp/$($(1)_DRIVER)/driver.mk
|
||||
endef |
||||
|
||||
GDISP_DRIVER_LIST:=
|
||||
|
||||
SRC += $(VISUALIZER_DIR)/visualizer.c \
|
||||
$(VISUALIZER_DIR)/visualizer_keyframes.c
|
||||
EXTRAINCDIRS += $(GFXINC) $(VISUALIZER_DIR)
|
||||
GFXLIB = $(LIB_PATH)/ugfx
|
||||
VPATH += $(VISUALIZER_PATH)
|
||||
|
||||
OPT_DEFS += -DVISUALIZER_ENABLE
|
||||
|
||||
ifdef LCD_ENABLE |
||||
OPT_DEFS += -DLCD_ENABLE
|
||||
ULIBS += -lm
|
||||
endif |
||||
|
||||
ifeq ($(strip $(LCD_ENABLE)), yes) |
||||
SRC += $(VISUALIZER_DIR)/lcd_keyframes.c
|
||||
ifeq ($(strip $(LCD_BACKLIGHT_ENABLE)), yes)
|
||||
OPT_DEFS += -DLCD_BACKLIGHT_ENABLE
|
||||
SRC += $(VISUALIZER_DIR)/lcd_backlight.c
|
||||
SRC += $(VISUALIZER_DIR)/lcd_backlight_keyframes.c
|
||||
endif
|
||||
# Note, that the linker will strip out any resources that are not actually in use
|
||||
SRC += $(VISUALIZER_DIR)/resources/lcd_logo.c
|
||||
$(eval $(call ADD_DRIVER,LCD)) |
||||
endif |
||||
|
||||
ifeq ($(strip $(BACKLIGHT_ENABLE)), yes) |
||||
SRC += $(VISUALIZER_DIR)/led_backlight_keyframes.c
|
||||
$(eval $(call ADD_DRIVER,LED)) |
||||
endif |
||||
|
||||
SRC += $(VISUALIZER_DIR)/default_animations.c
|
||||
|
||||
include $(GFXLIB)/gfx.mk |
||||
# For the common_gfxconf.h
|
||||
GFXINC += quantum/visualizer
|
||||
|
||||
GFXSRC := $(patsubst $(TOP_DIR)/%,%,$(GFXSRC))
|
||||
GFXDEFS := $(patsubst %,-D%,$(patsubst -D%,%,$(GFXDEFS)))
|
||||
|
||||
GDISP_LIST_COMMA=,
|
||||
GDISP_LIST_EMPTY=
|
||||
GDISP_LIST_SPACE=$(GDISP_LIST_EMPTY) $(GDISP_LIST_EMPTY)
|
||||
|
||||
GDISP_DRIVER_LIST := $(strip $(GDISP_DRIVER_LIST))
|
||||
GDISP_DRIVER_LIST := $(subst $(GDISP_LIST_SPACE),$(GDISP_LIST_COMMA),$(GDISP_DRIVER_LIST))
|
||||
|
||||
GFXDEFS +=-DGDISP_DRIVER_LIST="$(GDISP_DRIVER_LIST)"
|
||||
|
||||
ifneq ("$(wildcard $(KEYMAP_PATH)/visualizer.c)","") |
||||
SRC += $(KEYMAP_PATH)/visualizer.c
|
||||
else
|
||||
VISUALIZER_1 := $(KEYBOARD_PATH_1)/visualizer.c
|
||||
VISUALIZER_2 := $(KEYBOARD_PATH_2)/visualizer.c
|
||||
VISUALIZER_3 := $(KEYBOARD_PATH_3)/visualizer.c
|
||||
VISUALIZER_4 := $(KEYBOARD_PATH_4)/visualizer.c
|
||||
VISUALIZER_5 := $(KEYBOARD_PATH_5)/visualizer.c
|
||||
|
||||
ifneq ("$(wildcard $(VISUALIZER_5))","")
|
||||
SRC += $(VISUALIZER_5)
|
||||
endif
|
||||
ifneq ("$(wildcard $(VISUALIZER_4))","")
|
||||
SRC += $(VISUALIZER_4)
|
||||
endif
|
||||
ifneq ("$(wildcard $(VISUALIZER_3))","")
|
||||
SRC += $(VISUALIZER_3)
|
||||
endif
|
||||
ifneq ("$(wildcard $(VISUALIZER_2))","")
|
||||
SRC += $(VISUALIZER_2)
|
||||
endif
|
||||
ifneq ("$(wildcard $(VISUALIZER_1))","")
|
||||
SRC += $(VISUALIZER_1)
|
||||
endif
|
||||
endif |
||||
|
||||
ifdef EMULATOR |
||||
UINCDIR += $(TMK_DIR)/common
|
||||
endif |
||||
@ -1,23 +0,0 @@ |
||||
/* Copyright 2017 Fred Sundvik
|
||||
* |
||||
* This program is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, either version 2 of the License, or |
||||
* (at your option) any later version. |
||||
* |
||||
* This program is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
|
||||
#include "visualizer_keyframes.h" |
||||
|
||||
bool keyframe_no_operation(keyframe_animation_t* animation, visualizer_state_t* state) { |
||||
(void)animation; |
||||
(void)state; |
||||
return false; |
||||
} |
||||
@ -1,23 +0,0 @@ |
||||
/* Copyright 2017 Fred Sundvik
|
||||
* |
||||
* This program is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, either version 2 of the License, or |
||||
* (at your option) any later version. |
||||
* |
||||
* This program is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
|
||||
#pragma once |
||||
|
||||
#include "visualizer.h" |
||||
|
||||
// Some predefined keyframe functions that can be used by the user code
|
||||
// Does nothing, useful for adding delays
|
||||
bool keyframe_no_operation(keyframe_animation_t* animation, visualizer_state_t* state); |
||||
Loading…
Reference in new issue