* 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); |