* Purge uGFX. * Remove remnants of visualizer. * Remove remnants of uGFX.pull/14730/head
@ -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,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 | |||||
}; |
@ -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); |