@ -0,0 +1,3 @@ | |||
GFXINC += drivers/ugfx/gdisp/is31fl3731c | |||
GFXSRC += drivers/ugfx/gdisp/is31fl3731c/gdisp_is31fl3731c.c | |||
GDISP_DRIVER_LIST += GDISPVMT_IS31FL3731C_QMK |
@ -0,0 +1,3 @@ | |||
GFXINC += drivers/ugfx/gdisp/st7565 | |||
GFXSRC += drivers/ugfx/gdisp/st7565/gdisp_lld_ST7565.c | |||
GDISP_DRIVER_LIST += GDISPVMT_ST7565_QMK |
@ -1,30 +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_ANIMATIONS_H_ | |||
#define KEYBOARDS_ERGODOX_INFINITY_ANIMATIONS_H_ | |||
#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; | |||
#endif /* KEYBOARDS_ERGODOX_INFINITY_ANIMATIONS_H_ */ |
@ -0,0 +1,110 @@ | |||
/* | |||
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 */ |
@ -0,0 +1,113 @@ | |||
/* | |||
* 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 | |||
#define ST7565_LCD_BIAS ST7565_LCD_BIAS_9 // actually 6 | |||
#define ST7565_ADC ST7565_ADC_NORMAL | |||
#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_GPIOPORT GPIOC | |||
#define ST7565_PORT PORTC | |||
#define ST7565_A0_PIN 7 | |||
#define ST7565_RST_PIN 8 | |||
#define ST7565_MOSI_PIN 6 | |||
#define ST7565_SLCK_PIN 5 | |||
#define ST7565_SS_PIN 4 | |||
#define palSetPadModeRaw(portname, bits) \ | |||
ST7565_PORT->PCR[ST7565_##portname##_PIN] = bits | |||
#define palSetPadModeNamed(portname, portmode) \ | |||
palSetPadMode(ST7565_GPIOPORT, ST7565_##portname##_PIN, portmode) | |||
#define ST7565_SPI_MODE PORTx_PCRn_DSE | PORTx_PCRn_MUX(2) | |||
// 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 = ST7565_GPIOPORT, | |||
// brief The chip select line pad number - when not using pcs. | |||
.sspad=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; | |||
palSetPadModeNamed(A0, PAL_MODE_OUTPUT_PUSHPULL); | |||
palSetPad(ST7565_GPIOPORT, ST7565_A0_PIN); | |||
palSetPadModeNamed(RST, PAL_MODE_OUTPUT_PUSHPULL); | |||
palSetPad(ST7565_GPIOPORT, ST7565_RST_PIN); | |||
palSetPadModeRaw(MOSI, ST7565_SPI_MODE); | |||
palSetPadModeRaw(SLCK, ST7565_SPI_MODE); | |||
palSetPadModeNamed(SS, PAL_MODE_OUTPUT_PUSHPULL); | |||
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; | |||
if (state) { | |||
palClearPad(ST7565_GPIOPORT, ST7565_RST_PIN); | |||
} | |||
else { | |||
palSetPad(ST7565_GPIOPORT, ST7565_RST_PIN); | |||
} | |||
} | |||
static GFXINLINE void enter_data_mode(GDisplay *g) { | |||
palSetPad(ST7565_GPIOPORT, ST7565_A0_PIN); | |||
} | |||
static GFXINLINE void enter_cmd_mode(GDisplay *g) { | |||
palClearPad(ST7565_GPIOPORT, ST7565_A0_PIN); | |||
} | |||
static GFXINLINE void write_data(GDisplay *g, uint8_t* data, uint16_t length) { | |||
(void) g; | |||
spiSend(&SPID1, length, data); | |||
} | |||
#endif /* _GDISP_LLD_BOARD_H */ |
@ -1,2 +0,0 @@ | |||
GFXINC += drivers/gdisp/IS31FL3731C | |||
GFXSRC += drivers/gdisp/IS31FL3731C/gdisp_IS31FL3731C.c |
@ -1,312 +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_ERGODOX | |||
#include "drivers/gdisp/IS31FL3731C/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_SCREEN_HEIGHT | |||
#define GDISP_SCREEN_HEIGHT 9 | |||
#endif | |||
#ifndef GDISP_SCREEN_WIDTH | |||
#define GDISP_SCREEN_WIDTH 16 | |||
#endif | |||
#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_SCREEN_WIDTH 16 | |||
#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,2 +0,0 @@ | |||
GFXINC += drivers/gdisp/st7565ergodox | |||
GFXSRC += drivers/gdisp/st7565ergodox/gdisp_lld_ST7565.c |
@ -1,362 +0,0 @@ | |||
/* | |||
pins_arduino.h - Pin definition functions for Arduino | |||
Part of Arduino - http://www.arduino.cc/ | |||
Copyright (c) 2007 David A. Mellis | |||
This library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
This library 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 | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General | |||
Public License along with this library; if not, write to the | |||
Free Software Foundation, Inc., 59 Temple Place, Suite 330, | |||
Boston, MA 02111-1307 USA | |||
$Id: wiring.h 249 2007-02-03 16:52:51Z mellis $ | |||
*/ | |||
#ifndef Pins_Arduino_h | |||
#define Pins_Arduino_h | |||
#include <avr/pgmspace.h> | |||
// Workaround for wrong definitions in "iom32u4.h". | |||
// This should be fixed in the AVR toolchain. | |||
#undef UHCON | |||
#undef UHINT | |||
#undef UHIEN | |||
#undef UHADDR | |||
#undef UHFNUM | |||
#undef UHFNUML | |||
#undef UHFNUMH | |||
#undef UHFLEN | |||
#undef UPINRQX | |||
#undef UPINTX | |||
#undef UPNUM | |||
#undef UPRST | |||
#undef UPCONX | |||
#undef UPCFG0X | |||
#undef UPCFG1X | |||
#undef UPSTAX | |||
#undef UPCFG2X | |||
#undef UPIENX | |||
#undef UPDATX | |||
#undef TCCR2A | |||
#undef WGM20 | |||
#undef WGM21 | |||
#undef COM2B0 | |||
#undef COM2B1 | |||
#undef COM2A0 | |||
#undef COM2A1 | |||
#undef TCCR2B | |||
#undef CS20 | |||
#undef CS21 | |||
#undef CS22 | |||
#undef WGM22 | |||
#undef FOC2B | |||
#undef FOC2A | |||
#undef TCNT2 | |||
#undef TCNT2_0 | |||
#undef TCNT2_1 | |||
#undef TCNT2_2 | |||
#undef TCNT2_3 | |||
#undef TCNT2_4 | |||
#undef TCNT2_5 | |||
#undef TCNT2_6 | |||
#undef TCNT2_7 | |||
#undef OCR2A | |||
#undef OCR2_0 | |||
#undef OCR2_1 | |||
#undef OCR2_2 | |||
#undef OCR2_3 | |||
#undef OCR2_4 | |||
#undef OCR2_5 | |||
#undef OCR2_6 | |||
#undef OCR2_7 | |||
#undef OCR2B | |||
#undef OCR2_0 | |||
#undef OCR2_1 | |||
#undef OCR2_2 | |||
#undef OCR2_3 | |||
#undef OCR2_4 | |||
#undef OCR2_5 | |||
#undef OCR2_6 | |||
#undef OCR2_7 | |||
#define NUM_DIGITAL_PINS 30 | |||
#define NUM_ANALOG_INPUTS 12 | |||
#define TX_RX_LED_INIT DDRD |= (1<<5), DDRB |= (1<<0) | |||
#define TXLED0 PORTD |= (1<<5) | |||
#define TXLED1 PORTD &= ~(1<<5) | |||
#define RXLED0 PORTB |= (1<<0) | |||
#define RXLED1 PORTB &= ~(1<<0) | |||
static const uint8_t SDA = 2; | |||
static const uint8_t SCL = 3; | |||
#define LED_BUILTIN 13 | |||
// Map SPI port to 'new' pins D14..D17 | |||
static const uint8_t SS = 17; | |||
static const uint8_t MOSI = 16; | |||
static const uint8_t MISO = 14; | |||
static const uint8_t SCK = 15; | |||
// Mapping of analog pins as digital I/O | |||
// A6-A11 share with digital pins | |||
static const uint8_t ADC0 = 18; | |||
static const uint8_t ADC1 = 19; | |||
static const uint8_t ADC2 = 20; | |||
static const uint8_t ADC3 = 21; | |||
static const uint8_t ADC4 = 22; | |||
static const uint8_t ADC5 = 23; | |||
static const uint8_t ADC6 = 24; // D4 | |||
static const uint8_t ADC7 = 25; // D6 | |||
static const uint8_t ADC8 = 26; // D8 | |||
static const uint8_t ADC9 = 27; // D9 | |||
static const uint8_t ADC10 = 28; // D10 | |||
static const uint8_t ADC11 = 29; // D12 | |||
#define digitalPinToPCICR(p) ((((p) >= 8 && (p) <= 11) || ((p) >= 14 && (p) <= 17) || ((p) >= A8 && (p) <= A10)) ? (&PCICR) : ((uint8_t *)0)) | |||
#define digitalPinToPCICRbit(p) 0 | |||
#define digitalPinToPCMSK(p) ((((p) >= 8 && (p) <= 11) || ((p) >= 14 && (p) <= 17) || ((p) >= A8 && (p) <= A10)) ? (&PCMSK0) : ((uint8_t *)0)) | |||
#define digitalPinToPCMSKbit(p) ( ((p) >= 8 && (p) <= 11) ? (p) - 4 : ((p) == 14 ? 3 : ((p) == 15 ? 1 : ((p) == 16 ? 2 : ((p) == 17 ? 0 : (p - A8 + 4)))))) | |||
// __AVR_ATmega32U4__ has an unusual mapping of pins to channels | |||
extern const uint8_t PROGMEM analog_pin_to_channel_PGM[]; | |||
#define analogPinToChannel(P) ( pgm_read_byte( analog_pin_to_channel_PGM + (P) ) ) | |||
#define digitalPinToInterrupt(p) ((p) == 0 ? 2 : ((p) == 1 ? 3 : ((p) == 2 ? 1 : ((p) == 3 ? 0 : ((p) == 7 ? 4 : NOT_AN_INTERRUPT))))) | |||
#ifdef ARDUINO_MAIN | |||
// On the Arduino board, digital pins are also used | |||
// for the analog output (software PWM). Analog input | |||
// pins are a separate set. | |||
// ATMEL ATMEGA32U4 / ARDUINO LEONARDO | |||
// | |||
// D0 PD2 RXD1/INT2 | |||
// D1 PD3 TXD1/INT3 | |||
// D2 PD1 SDA SDA/INT1 | |||
// D3# PD0 PWM8/SCL OC0B/SCL/INT0 | |||
// D4 A6 PD4 ADC8 | |||
// D5# PC6 ??? OC3A/#OC4A | |||
// D6# A7 PD7 FastPWM #OC4D/ADC10 | |||
// D7 PE6 INT6/AIN0 | |||
// | |||
// D8 A8 PB4 ADC11/PCINT4 | |||
// D9# A9 PB5 PWM16 OC1A/#OC4B/ADC12/PCINT5 | |||
// D10# A10 PB6 PWM16 OC1B/0c4B/ADC13/PCINT6 | |||
// D11# PB7 PWM8/16 0C0A/OC1C/#RTS/PCINT7 | |||
// D12 A11 PD6 T1/#OC4D/ADC9 | |||
// D13# PC7 PWM10 CLK0/OC4A | |||
// | |||
// A0 D18 PF7 ADC7 | |||
// A1 D19 PF6 ADC6 | |||
// A2 D20 PF5 ADC5 | |||
// A3 D21 PF4 ADC4 | |||
// A4 D22 PF1 ADC1 | |||
// A5 D23 PF0 ADC0 | |||
// | |||
// New pins D14..D17 to map SPI port to digital pins | |||
// | |||
// MISO D14 PB3 MISO,PCINT3 | |||
// SCK D15 PB1 SCK,PCINT1 | |||
// MOSI D16 PB2 MOSI,PCINT2 | |||
// SS D17 PB0 RXLED,SS/PCINT0 | |||
// | |||
// Connected LEDs on board for TX and RX | |||
// TXLED D24 PD5 XCK1 | |||
// RXLED D17 PB0 | |||
// HWB PE2 HWB | |||
// these arrays map port names (e.g. port B) to the | |||
// appropriate addresses for various functions (e.g. reading | |||
// and writing) | |||
const uint16_t PROGMEM port_to_mode_PGM[] = { | |||
NOT_A_PORT, | |||
NOT_A_PORT, | |||
(uint16_t) &DDRB, | |||
(uint16_t) &DDRC, | |||
(uint16_t) &DDRD, | |||
(uint16_t) &DDRE, | |||
(uint16_t) &DDRF, | |||
}; | |||
const uint16_t PROGMEM port_to_output_PGM[] = { | |||
NOT_A_PORT, | |||
NOT_A_PORT, | |||
(uint16_t) &PORTB, | |||
(uint16_t) &PORTC, | |||
(uint16_t) &PORTD, | |||
(uint16_t) &PORTE, | |||
(uint16_t) &PORTF, | |||
}; | |||
const uint16_t PROGMEM port_to_input_PGM[] = { | |||
NOT_A_PORT, | |||
NOT_A_PORT, | |||
(uint16_t) &PINB, | |||
(uint16_t) &PINC, | |||
(uint16_t) &PIND, | |||
(uint16_t) &PINE, | |||
(uint16_t) &PINF, | |||
}; | |||
const uint8_t PROGMEM digital_pin_to_port_PGM[] = { | |||
PD, // D0 - PD2 | |||
PD, // D1 - PD3 | |||
PD, // D2 - PD1 | |||
PD, // D3 - PD0 | |||
PD, // D4 - PD4 | |||
PC, // D5 - PC6 | |||
PD, // D6 - PD7 | |||
PE, // D7 - PE6 | |||
PB, // D8 - PB4 | |||
PB, // D9 - PB5 | |||
PB, // D10 - PB6 | |||
PB, // D11 - PB7 | |||
PD, // D12 - PD6 | |||
PC, // D13 - PC7 | |||
PB, // D14 - MISO - PB3 | |||
PB, // D15 - SCK - PB1 | |||
PB, // D16 - MOSI - PB2 | |||
PB, // D17 - SS - PB0 | |||
PF, // D18 - A0 - PF7 | |||
PF, // D19 - A1 - PF6 | |||
PF, // D20 - A2 - PF5 | |||
PF, // D21 - A3 - PF4 | |||
PF, // D22 - A4 - PF1 | |||
PF, // D23 - A5 - PF0 | |||
PD, // D24 - PD5 | |||
PD, // D25 / D6 - A7 - PD7 | |||
PB, // D26 / D8 - A8 - PB4 | |||
PB, // D27 / D9 - A9 - PB5 | |||
PB, // D28 / D10 - A10 - PB6 | |||
PD, // D29 / D12 - A11 - PD6 | |||
}; | |||
const uint8_t PROGMEM digital_pin_to_bit_mask_PGM[] = { | |||
_BV(2), // D0 - PD2 | |||
_BV(3), // D1 - PD3 | |||
_BV(1), // D2 - PD1 | |||
_BV(0), // D3 - PD0 | |||
_BV(4), // D4 - PD4 | |||
_BV(6), // D5 - PC6 | |||
_BV(7), // D6 - PD7 | |||
_BV(6), // D7 - PE6 | |||
_BV(4), // D8 - PB4 | |||
_BV(5), // D9 - PB5 | |||
_BV(6), // D10 - PB6 | |||
_BV(7), // D11 - PB7 | |||
_BV(6), // D12 - PD6 | |||
_BV(7), // D13 - PC7 | |||
_BV(3), // D14 - MISO - PB3 | |||
_BV(1), // D15 - SCK - PB1 | |||
_BV(2), // D16 - MOSI - PB2 | |||
_BV(0), // D17 - SS - PB0 | |||
_BV(7), // D18 - A0 - PF7 | |||
_BV(6), // D19 - A1 - PF6 | |||
_BV(5), // D20 - A2 - PF5 | |||
_BV(4), // D21 - A3 - PF4 | |||
_BV(1), // D22 - A4 - PF1 | |||
_BV(0), // D23 - A5 - PF0 | |||
_BV(5), // D24 - PD5 | |||
_BV(7), // D25 / D6 - A7 - PD7 | |||
_BV(4), // D26 / D8 - A8 - PB4 | |||
_BV(5), // D27 / D9 - A9 - PB5 | |||
_BV(6), // D28 / D10 - A10 - PB6 | |||
_BV(6), // D29 / D12 - A11 - PD6 | |||
}; | |||
const uint8_t PROGMEM digital_pin_to_timer_PGM[] = { | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
TIMER0B, /* 3 */ | |||
NOT_ON_TIMER, | |||
TIMER3A, /* 5 */ | |||
TIMER4D, /* 6 */ | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
TIMER1A, /* 9 */ | |||
TIMER1B, /* 10 */ | |||
TIMER0A, /* 11 */ | |||
NOT_ON_TIMER, | |||
TIMER4A, /* 13 */ | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
}; | |||
const uint8_t PROGMEM analog_pin_to_channel_PGM[] = { | |||
7, // A0 PF7 ADC7 | |||
6, // A1 PF6 ADC6 | |||
5, // A2 PF5 ADC5 | |||
4, // A3 PF4 ADC4 | |||
1, // A4 PF1 ADC1 | |||
0, // A5 PF0 ADC0 | |||
8, // A6 D4 PD4 ADC8 | |||
10, // A7 D6 PD7 ADC10 | |||
11, // A8 D8 PB4 ADC11 | |||
12, // A9 D9 PB5 ADC12 | |||
13, // A10 D10 PB6 ADC13 | |||
9 // A11 D12 PD6 ADC9 | |||
}; | |||
#endif /* ARDUINO_MAIN */ | |||
// These serial port names are intended to allow libraries and architecture-neutral | |||
// sketches to automatically default to the correct port name for a particular type | |||
// of use. For example, a GPS module would normally connect to SERIAL_PORT_HARDWARE_OPEN, | |||
// the first hardware serial port whose RX/TX pins are not dedicated to another use. | |||
// | |||
// SERIAL_PORT_MONITOR Port which normally prints to the Arduino Serial Monitor | |||
// | |||
// SERIAL_PORT_USBVIRTUAL Port which is USB virtual serial | |||
// | |||
// SERIAL_PORT_LINUXBRIDGE Port which connects to a Linux system via Bridge library | |||
// | |||
// SERIAL_PORT_HARDWARE Hardware serial port, physical RX & TX pins. | |||
// | |||
// SERIAL_PORT_HARDWARE_OPEN Hardware serial ports which are open for use. Their RX & TX | |||
// pins are NOT connected to anything by default. | |||
#define SERIAL_PORT_MONITOR Serial | |||
#define SERIAL_PORT_USBVIRTUAL Serial | |||
#define SERIAL_PORT_HARDWARE Serial1 | |||
#define SERIAL_PORT_HARDWARE_OPEN Serial1 | |||
#endif /* Pins_Arduino_h */ |
@ -1,362 +0,0 @@ | |||
/* | |||
pins_arduino.h - Pin definition functions for Arduino | |||
Part of Arduino - http://www.arduino.cc/ | |||
Copyright (c) 2007 David A. Mellis | |||
This library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
This library 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 | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General | |||
Public License along with this library; if not, write to the | |||
Free Software Foundation, Inc., 59 Temple Place, Suite 330, | |||
Boston, MA 02111-1307 USA | |||
$Id: wiring.h 249 2007-02-03 16:52:51Z mellis $ | |||
*/ | |||
#ifndef Pins_Arduino_h | |||
#define Pins_Arduino_h | |||
#include <avr/pgmspace.h> | |||
// Workaround for wrong definitions in "iom32u4.h". | |||
// This should be fixed in the AVR toolchain. | |||
#undef UHCON | |||
#undef UHINT | |||
#undef UHIEN | |||
#undef UHADDR | |||
#undef UHFNUM | |||
#undef UHFNUML | |||
#undef UHFNUMH | |||
#undef UHFLEN | |||
#undef UPINRQX | |||
#undef UPINTX | |||
#undef UPNUM | |||
#undef UPRST | |||
#undef UPCONX | |||
#undef UPCFG0X | |||
#undef UPCFG1X | |||
#undef UPSTAX | |||
#undef UPCFG2X | |||
#undef UPIENX | |||
#undef UPDATX | |||
#undef TCCR2A | |||
#undef WGM20 | |||
#undef WGM21 | |||
#undef COM2B0 | |||
#undef COM2B1 | |||
#undef COM2A0 | |||
#undef COM2A1 | |||
#undef TCCR2B | |||
#undef CS20 | |||
#undef CS21 | |||
#undef CS22 | |||
#undef WGM22 | |||
#undef FOC2B | |||
#undef FOC2A | |||
#undef TCNT2 | |||
#undef TCNT2_0 | |||
#undef TCNT2_1 | |||
#undef TCNT2_2 | |||
#undef TCNT2_3 | |||
#undef TCNT2_4 | |||
#undef TCNT2_5 | |||
#undef TCNT2_6 | |||
#undef TCNT2_7 | |||
#undef OCR2A | |||
#undef OCR2_0 | |||
#undef OCR2_1 | |||
#undef OCR2_2 | |||
#undef OCR2_3 | |||
#undef OCR2_4 | |||
#undef OCR2_5 | |||
#undef OCR2_6 | |||
#undef OCR2_7 | |||
#undef OCR2B | |||
#undef OCR2_0 | |||
#undef OCR2_1 | |||
#undef OCR2_2 | |||
#undef OCR2_3 | |||
#undef OCR2_4 | |||
#undef OCR2_5 | |||
#undef OCR2_6 | |||
#undef OCR2_7 | |||
#define NUM_DIGITAL_PINS 30 | |||
#define NUM_ANALOG_INPUTS 12 | |||
#define TX_RX_LED_INIT DDRD |= (1<<5), DDRB |= (1<<0) | |||
#define TXLED0 PORTD |= (1<<5) | |||
#define TXLED1 PORTD &= ~(1<<5) | |||
#define RXLED0 PORTB |= (1<<0) | |||
#define RXLED1 PORTB &= ~(1<<0) | |||
static const uint8_t SDA = 2; | |||
static const uint8_t SCL = 3; | |||
#define LED_BUILTIN 13 | |||
// Map SPI port to 'new' pins D14..D17 | |||
static const uint8_t SS = 17; | |||
static const uint8_t MOSI = 16; | |||
static const uint8_t MISO = 14; | |||
static const uint8_t SCK = 15; | |||
// Mapping of analog pins as digital I/O | |||
// A6-A11 share with digital pins | |||
static const uint8_t ADC0 = 18; | |||
static const uint8_t ADC1 = 19; | |||
static const uint8_t ADC2 = 20; | |||
static const uint8_t ADC3 = 21; | |||
static const uint8_t ADC4 = 22; | |||
static const uint8_t ADC5 = 23; | |||
static const uint8_t ADC6 = 24; // D4 | |||
static const uint8_t ADC7 = 25; // D6 | |||
static const uint8_t ADC8 = 26; // D8 | |||
static const uint8_t ADC9 = 27; // D9 | |||
static const uint8_t ADC10 = 28; // D10 | |||
static const uint8_t ADC11 = 29; // D12 | |||
#define digitalPinToPCICR(p) ((((p) >= 8 && (p) <= 11) || ((p) >= 14 && (p) <= 17) || ((p) >= A8 && (p) <= A10)) ? (&PCICR) : ((uint8_t *)0)) | |||
#define digitalPinToPCICRbit(p) 0 | |||
#define digitalPinToPCMSK(p) ((((p) >= 8 && (p) <= 11) || ((p) >= 14 && (p) <= 17) || ((p) >= A8 && (p) <= A10)) ? (&PCMSK0) : ((uint8_t *)0)) | |||
#define digitalPinToPCMSKbit(p) ( ((p) >= 8 && (p) <= 11) ? (p) - 4 : ((p) == 14 ? 3 : ((p) == 15 ? 1 : ((p) == 16 ? 2 : ((p) == 17 ? 0 : (p - A8 + 4)))))) | |||
// __AVR_ATmega32U4__ has an unusual mapping of pins to channels | |||
extern const uint8_t PROGMEM analog_pin_to_channel_PGM[]; | |||
#define analogPinToChannel(P) ( pgm_read_byte( analog_pin_to_channel_PGM + (P) ) ) | |||
#define digitalPinToInterrupt(p) ((p) == 0 ? 2 : ((p) == 1 ? 3 : ((p) == 2 ? 1 : ((p) == 3 ? 0 : ((p) == 7 ? 4 : NOT_AN_INTERRUPT))))) | |||
#ifdef ARDUINO_MAIN | |||
// On the Arduino board, digital pins are also used | |||
// for the analog output (software PWM). Analog input | |||
// pins are a separate set. | |||
// ATMEL ATMEGA32U4 / ARDUINO LEONARDO | |||
// | |||
// D0 PD2 RXD1/INT2 | |||
// D1 PD3 TXD1/INT3 | |||
// D2 PD1 SDA SDA/INT1 | |||
// D3# PD0 PWM8/SCL OC0B/SCL/INT0 | |||
// D4 A6 PD4 ADC8 | |||
// D5# PC6 ??? OC3A/#OC4A | |||
// D6# A7 PD7 FastPWM #OC4D/ADC10 | |||
// D7 PE6 INT6/AIN0 | |||
// | |||
// D8 A8 PB4 ADC11/PCINT4 | |||
// D9# A9 PB5 PWM16 OC1A/#OC4B/ADC12/PCINT5 | |||
// D10# A10 PB6 PWM16 OC1B/0c4B/ADC13/PCINT6 | |||
// D11# PB7 PWM8/16 0C0A/OC1C/#RTS/PCINT7 | |||
// D12 A11 PD6 T1/#OC4D/ADC9 | |||
// D13# PC7 PWM10 CLK0/OC4A | |||
// | |||
// A0 D18 PF7 ADC7 | |||
// A1 D19 PF6 ADC6 | |||
// A2 D20 PF5 ADC5 | |||
// A3 D21 PF4 ADC4 | |||
// A4 D22 PF1 ADC1 | |||
// A5 D23 PF0 ADC0 | |||
// | |||
// New pins D14..D17 to map SPI port to digital pins | |||
// | |||
// MISO D14 PB3 MISO,PCINT3 | |||
// SCK D15 PB1 SCK,PCINT1 | |||
// MOSI D16 PB2 MOSI,PCINT2 | |||
// SS D17 PB0 RXLED,SS/PCINT0 | |||
// | |||
// Connected LEDs on board for TX and RX | |||
// TXLED D24 PD5 XCK1 | |||
// RXLED D17 PB0 | |||
// HWB PE2 HWB | |||
// these arrays map port names (e.g. port B) to the | |||
// appropriate addresses for various functions (e.g. reading | |||
// and writing) | |||
const uint16_t PROGMEM port_to_mode_PGM[] = { | |||
NOT_A_PORT, | |||
NOT_A_PORT, | |||
(uint16_t) &DDRB, | |||
(uint16_t) &DDRC, | |||
(uint16_t) &DDRD, | |||
(uint16_t) &DDRE, | |||
(uint16_t) &DDRF, | |||
}; | |||
const uint16_t PROGMEM port_to_output_PGM[] = { | |||
NOT_A_PORT, | |||
NOT_A_PORT, | |||
(uint16_t) &PORTB, | |||
(uint16_t) &PORTC, | |||
(uint16_t) &PORTD, | |||
(uint16_t) &PORTE, | |||
(uint16_t) &PORTF, | |||
}; | |||
const uint16_t PROGMEM port_to_input_PGM[] = { | |||
NOT_A_PORT, | |||
NOT_A_PORT, | |||
(uint16_t) &PINB, | |||
(uint16_t) &PINC, | |||
(uint16_t) &PIND, | |||
(uint16_t) &PINE, | |||
(uint16_t) &PINF, | |||
}; | |||
const uint8_t PROGMEM digital_pin_to_port_PGM[] = { | |||
PD, // D0 - PD2 | |||
PD, // D1 - PD3 | |||
PD, // D2 - PD1 | |||
PD, // D3 - PD0 | |||
PD, // D4 - PD4 | |||
PC, // D5 - PC6 | |||
PD, // D6 - PD7 | |||
PE, // D7 - PE6 | |||
PB, // D8 - PB4 | |||
PB, // D9 - PB5 | |||
PB, // D10 - PB6 | |||
PB, // D11 - PB7 | |||
PD, // D12 - PD6 | |||
PC, // D13 - PC7 | |||
PB, // D14 - MISO - PB3 | |||
PB, // D15 - SCK - PB1 | |||
PB, // D16 - MOSI - PB2 | |||
PB, // D17 - SS - PB0 | |||
PF, // D18 - A0 - PF7 | |||
PF, // D19 - A1 - PF6 | |||
PF, // D20 - A2 - PF5 | |||
PF, // D21 - A3 - PF4 | |||
PF, // D22 - A4 - PF1 | |||
PF, // D23 - A5 - PF0 | |||
PD, // D24 - PD5 | |||
PD, // D25 / D6 - A7 - PD7 | |||
PB, // D26 / D8 - A8 - PB4 | |||
PB, // D27 / D9 - A9 - PB5 | |||
PB, // D28 / D10 - A10 - PB6 | |||
PD, // D29 / D12 - A11 - PD6 | |||
}; | |||
const uint8_t PROGMEM digital_pin_to_bit_mask_PGM[] = { | |||
_BV(2), // D0 - PD2 | |||
_BV(3), // D1 - PD3 | |||
_BV(1), // D2 - PD1 | |||
_BV(0), // D3 - PD0 | |||
_BV(4), // D4 - PD4 | |||
_BV(6), // D5 - PC6 | |||
_BV(7), // D6 - PD7 | |||
_BV(6), // D7 - PE6 | |||
_BV(4), // D8 - PB4 | |||
_BV(5), // D9 - PB5 | |||
_BV(6), // D10 - PB6 | |||
_BV(7), // D11 - PB7 | |||
_BV(6), // D12 - PD6 | |||
_BV(7), // D13 - PC7 | |||
_BV(3), // D14 - MISO - PB3 | |||
_BV(1), // D15 - SCK - PB1 | |||
_BV(2), // D16 - MOSI - PB2 | |||
_BV(0), // D17 - SS - PB0 | |||
_BV(7), // D18 - A0 - PF7 | |||
_BV(6), // D19 - A1 - PF6 | |||
_BV(5), // D20 - A2 - PF5 | |||
_BV(4), // D21 - A3 - PF4 | |||
_BV(1), // D22 - A4 - PF1 | |||
_BV(0), // D23 - A5 - PF0 | |||
_BV(5), // D24 - PD5 | |||
_BV(7), // D25 / D6 - A7 - PD7 | |||
_BV(4), // D26 / D8 - A8 - PB4 | |||
_BV(5), // D27 / D9 - A9 - PB5 | |||
_BV(6), // D28 / D10 - A10 - PB6 | |||
_BV(6), // D29 / D12 - A11 - PD6 | |||
}; | |||
const uint8_t PROGMEM digital_pin_to_timer_PGM[] = { | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
TIMER0B, /* 3 */ | |||
NOT_ON_TIMER, | |||
TIMER3A, /* 5 */ | |||
TIMER4D, /* 6 */ | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
TIMER1A, /* 9 */ | |||
TIMER1B, /* 10 */ | |||
TIMER0A, /* 11 */ | |||
NOT_ON_TIMER, | |||
TIMER4A, /* 13 */ | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
}; | |||
const uint8_t PROGMEM analog_pin_to_channel_PGM[] = { | |||
7, // A0 PF7 ADC7 | |||
6, // A1 PF6 ADC6 | |||
5, // A2 PF5 ADC5 | |||
4, // A3 PF4 ADC4 | |||
1, // A4 PF1 ADC1 | |||
0, // A5 PF0 ADC0 | |||
8, // A6 D4 PD4 ADC8 | |||
10, // A7 D6 PD7 ADC10 | |||
11, // A8 D8 PB4 ADC11 | |||
12, // A9 D9 PB5 ADC12 | |||
13, // A10 D10 PB6 ADC13 | |||
9 // A11 D12 PD6 ADC9 | |||
}; | |||
#endif /* ARDUINO_MAIN */ | |||
// These serial port names are intended to allow libraries and architecture-neutral | |||
// sketches to automatically default to the correct port name for a particular type | |||
// of use. For example, a GPS module would normally connect to SERIAL_PORT_HARDWARE_OPEN, | |||
// the first hardware serial port whose RX/TX pins are not dedicated to another use. | |||
// | |||
// SERIAL_PORT_MONITOR Port which normally prints to the Arduino Serial Monitor | |||
// | |||
// SERIAL_PORT_USBVIRTUAL Port which is USB virtual serial | |||
// | |||
// SERIAL_PORT_LINUXBRIDGE Port which connects to a Linux system via Bridge library | |||
// | |||
// SERIAL_PORT_HARDWARE Hardware serial port, physical RX & TX pins. | |||
// | |||
// SERIAL_PORT_HARDWARE_OPEN Hardware serial ports which are open for use. Their RX & TX | |||
// pins are NOT connected to anything by default. | |||
#define SERIAL_PORT_MONITOR Serial | |||
#define SERIAL_PORT_USBVIRTUAL Serial | |||
#define SERIAL_PORT_HARDWARE Serial1 | |||
#define SERIAL_PORT_HARDWARE_OPEN Serial1 | |||
#endif /* Pins_Arduino_h */ |
@ -1,362 +0,0 @@ | |||
/* | |||
pins_arduino.h - Pin definition functions for Arduino | |||
Part of Arduino - http://www.arduino.cc/ | |||
Copyright (c) 2007 David A. Mellis | |||
This library is free software; you can redistribute it and/or | |||
modify it under the terms of the GNU Lesser General Public | |||
License as published by the Free Software Foundation; either | |||
version 2.1 of the License, or (at your option) any later version. | |||
This library 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 | |||
Lesser General Public License for more details. | |||
You should have received a copy of the GNU Lesser General | |||
Public License along with this library; if not, write to the | |||
Free Software Foundation, Inc., 59 Temple Place, Suite 330, | |||
Boston, MA 02111-1307 USA | |||
$Id: wiring.h 249 2007-02-03 16:52:51Z mellis $ | |||
*/ | |||
#ifndef Pins_Arduino_h | |||
#define Pins_Arduino_h | |||
#include <avr/pgmspace.h> | |||
// Workaround for wrong definitions in "iom32u4.h". | |||
// This should be fixed in the AVR toolchain. | |||
#undef UHCON | |||
#undef UHINT | |||
#undef UHIEN | |||
#undef UHADDR | |||
#undef UHFNUM | |||
#undef UHFNUML | |||
#undef UHFNUMH | |||
#undef UHFLEN | |||
#undef UPINRQX | |||
#undef UPINTX | |||
#undef UPNUM | |||
#undef UPRST | |||
#undef UPCONX | |||
#undef UPCFG0X | |||
#undef UPCFG1X | |||
#undef UPSTAX | |||
#undef UPCFG2X | |||
#undef UPIENX | |||
#undef UPDATX | |||
#undef TCCR2A | |||
#undef WGM20 | |||
#undef WGM21 | |||
#undef COM2B0 | |||
#undef COM2B1 | |||
#undef COM2A0 | |||
#undef COM2A1 | |||
#undef TCCR2B | |||
#undef CS20 | |||
#undef CS21 | |||
#undef CS22 | |||
#undef WGM22 | |||
#undef FOC2B | |||
#undef FOC2A | |||
#undef TCNT2 | |||
#undef TCNT2_0 | |||
#undef TCNT2_1 | |||
#undef TCNT2_2 | |||
#undef TCNT2_3 | |||
#undef TCNT2_4 | |||
#undef TCNT2_5 | |||
#undef TCNT2_6 | |||
#undef TCNT2_7 | |||
#undef OCR2A | |||
#undef OCR2_0 | |||
#undef OCR2_1 | |||
#undef OCR2_2 | |||
#undef OCR2_3 | |||
#undef OCR2_4 | |||
#undef OCR2_5 | |||
#undef OCR2_6 | |||
#undef OCR2_7 | |||
#undef OCR2B | |||
#undef OCR2_0 | |||
#undef OCR2_1 | |||
#undef OCR2_2 | |||
#undef OCR2_3 | |||
#undef OCR2_4 | |||
#undef OCR2_5 | |||
#undef OCR2_6 | |||
#undef OCR2_7 | |||
#define NUM_DIGITAL_PINS 30 | |||
#define NUM_ANALOG_INPUTS 12 | |||
#define TX_RX_LED_INIT DDRD |= (1<<5), DDRB |= (1<<0) | |||
#define TXLED0 PORTD |= (1<<5) | |||
#define TXLED1 PORTD &= ~(1<<5) | |||
#define RXLED0 PORTB |= (1<<0) | |||
#define RXLED1 PORTB &= ~(1<<0) | |||
static const uint8_t SDA = 2; | |||
static const uint8_t SCL = 3; | |||
#define LED_BUILTIN 13 | |||
// Map SPI port to 'new' pins D14..D17 | |||
static const uint8_t SS = 17; | |||
static const uint8_t MOSI = 16; | |||
static const uint8_t MISO = 14; | |||
static const uint8_t SCK = 15; | |||
// Mapping of analog pins as digital I/O | |||
// A6-A11 share with digital pins | |||
static const uint8_t ADC0 = 18; | |||
static const uint8_t ADC1 = 19; | |||
static const uint8_t ADC2 = 20; | |||
static const uint8_t ADC3 = 21; | |||
static const uint8_t ADC4 = 22; | |||
static const uint8_t ADC5 = 23; | |||
static const uint8_t ADC6 = 24; // D4 | |||
static const uint8_t ADC7 = 25; // D6 | |||
static const uint8_t ADC8 = 26; // D8 | |||
static const uint8_t ADC9 = 27; // D9 | |||
static const uint8_t ADC10 = 28; // D10 | |||
static const uint8_t ADC11 = 29; // D12 | |||
#define digitalPinToPCICR(p) ((((p) >= 8 && (p) <= 11) || ((p) >= 14 && (p) <= 17) || ((p) >= A8 && (p) <= A10)) ? (&PCICR) : ((uint8_t *)0)) | |||
#define digitalPinToPCICRbit(p) 0 | |||
#define digitalPinToPCMSK(p) ((((p) >= 8 && (p) <= 11) || ((p) >= 14 && (p) <= 17) || ((p) >= A8 && (p) <= A10)) ? (&PCMSK0) : ((uint8_t *)0)) | |||
#define digitalPinToPCMSKbit(p) ( ((p) >= 8 && (p) <= 11) ? (p) - 4 : ((p) == 14 ? 3 : ((p) == 15 ? 1 : ((p) == 16 ? 2 : ((p) == 17 ? 0 : (p - A8 + 4)))))) | |||
// __AVR_ATmega32U4__ has an unusual mapping of pins to channels | |||
extern const uint8_t PROGMEM analog_pin_to_channel_PGM[]; | |||
#define analogPinToChannel(P) ( pgm_read_byte( analog_pin_to_channel_PGM + (P) ) ) | |||
#define digitalPinToInterrupt(p) ((p) == 0 ? 2 : ((p) == 1 ? 3 : ((p) == 2 ? 1 : ((p) == 3 ? 0 : ((p) == 7 ? 4 : NOT_AN_INTERRUPT))))) | |||
#ifdef ARDUINO_MAIN | |||
// On the Arduino board, digital pins are also used | |||
// for the analog output (software PWM). Analog input | |||
// pins are a separate set. | |||
// ATMEL ATMEGA32U4 / ARDUINO LEONARDO | |||
// | |||
// D0 PD2 RXD1/INT2 | |||
// D1 PD3 TXD1/INT3 | |||
// D2 PD1 SDA SDA/INT1 | |||
// D3# PD0 PWM8/SCL OC0B/SCL/INT0 | |||
// D4 A6 PD4 ADC8 | |||
// D5# PC6 ??? OC3A/#OC4A | |||
// D6# A7 PD7 FastPWM #OC4D/ADC10 | |||
// D7 PE6 INT6/AIN0 | |||
// | |||
// D8 A8 PB4 ADC11/PCINT4 | |||
// D9# A9 PB5 PWM16 OC1A/#OC4B/ADC12/PCINT5 | |||
// D10# A10 PB6 PWM16 OC1B/0c4B/ADC13/PCINT6 | |||
// D11# PB7 PWM8/16 0C0A/OC1C/#RTS/PCINT7 | |||
// D12 A11 PD6 T1/#OC4D/ADC9 | |||
// D13# PC7 PWM10 CLK0/OC4A | |||
// | |||
// A0 D18 PF7 ADC7 | |||
// A1 D19 PF6 ADC6 | |||
// A2 D20 PF5 ADC5 | |||
// A3 D21 PF4 ADC4 | |||
// A4 D22 PF1 ADC1 | |||
// A5 D23 PF0 ADC0 | |||
// | |||
// New pins D14..D17 to map SPI port to digital pins | |||
// | |||
// MISO D14 PB3 MISO,PCINT3 | |||
// SCK D15 PB1 SCK,PCINT1 | |||
// MOSI D16 PB2 MOSI,PCINT2 | |||
// SS D17 PB0 RXLED,SS/PCINT0 | |||
// | |||
// Connected LEDs on board for TX and RX | |||
// TXLED D24 PD5 XCK1 | |||
// RXLED D17 PB0 | |||
// HWB PE2 HWB | |||
// these arrays map port names (e.g. port B) to the | |||
// appropriate addresses for various functions (e.g. reading | |||
// and writing) | |||
const uint16_t PROGMEM port_to_mode_PGM[] = { | |||
NOT_A_PORT, | |||
NOT_A_PORT, | |||
(uint16_t) &DDRB, | |||
(uint16_t) &DDRC, | |||
(uint16_t) &DDRD, | |||
(uint16_t) &DDRE, | |||
(uint16_t) &DDRF, | |||
}; | |||
const uint16_t PROGMEM port_to_output_PGM[] = { | |||
NOT_A_PORT, | |||
NOT_A_PORT, | |||
(uint16_t) &PORTB, | |||
(uint16_t) &PORTC, | |||
(uint16_t) &PORTD, | |||
(uint16_t) &PORTE, | |||
(uint16_t) &PORTF, | |||
}; | |||
const uint16_t PROGMEM port_to_input_PGM[] = { | |||
NOT_A_PORT, | |||
NOT_A_PORT, | |||
(uint16_t) &PINB, | |||
(uint16_t) &PINC, | |||
(uint16_t) &PIND, | |||
(uint16_t) &PINE, | |||
(uint16_t) &PINF, | |||
}; | |||
const uint8_t PROGMEM digital_pin_to_port_PGM[] = { | |||
PD, // D0 - PD2 | |||
PD, // D1 - PD3 | |||
PD, // D2 - PD1 | |||
PD, // D3 - PD0 | |||
PD, // D4 - PD4 | |||
PC, // D5 - PC6 | |||
PD, // D6 - PD7 | |||
PE, // D7 - PE6 | |||
PB, // D8 - PB4 | |||
PB, // D9 - PB5 | |||
PB, // D10 - PB6 | |||
PB, // D11 - PB7 | |||
PD, // D12 - PD6 | |||
PC, // D13 - PC7 | |||
PB, // D14 - MISO - PB3 | |||
PB, // D15 - SCK - PB1 | |||
PB, // D16 - MOSI - PB2 | |||
PB, // D17 - SS - PB0 | |||
PF, // D18 - A0 - PF7 | |||
PF, // D19 - A1 - PF6 | |||
PF, // D20 - A2 - PF5 | |||
PF, // D21 - A3 - PF4 | |||
PF, // D22 - A4 - PF1 | |||
PF, // D23 - A5 - PF0 | |||
PD, // D24 - PD5 | |||
PD, // D25 / D6 - A7 - PD7 | |||
PB, // D26 / D8 - A8 - PB4 | |||
PB, // D27 / D9 - A9 - PB5 | |||
PB, // D28 / D10 - A10 - PB6 | |||
PD, // D29 / D12 - A11 - PD6 | |||
}; | |||
const uint8_t PROGMEM digital_pin_to_bit_mask_PGM[] = { | |||
_BV(2), // D0 - PD2 | |||
_BV(3), // D1 - PD3 | |||
_BV(1), // D2 - PD1 | |||
_BV(0), // D3 - PD0 | |||
_BV(4), // D4 - PD4 | |||
_BV(6), // D5 - PC6 | |||
_BV(7), // D6 - PD7 | |||
_BV(6), // D7 - PE6 | |||
_BV(4), // D8 - PB4 | |||
_BV(5), // D9 - PB5 | |||
_BV(6), // D10 - PB6 | |||
_BV(7), // D11 - PB7 | |||
_BV(6), // D12 - PD6 | |||
_BV(7), // D13 - PC7 | |||
_BV(3), // D14 - MISO - PB3 | |||
_BV(1), // D15 - SCK - PB1 | |||
_BV(2), // D16 - MOSI - PB2 | |||
_BV(0), // D17 - SS - PB0 | |||
_BV(7), // D18 - A0 - PF7 | |||
_BV(6), // D19 - A1 - PF6 | |||
_BV(5), // D20 - A2 - PF5 | |||
_BV(4), // D21 - A3 - PF4 | |||
_BV(1), // D22 - A4 - PF1 | |||
_BV(0), // D23 - A5 - PF0 | |||
_BV(5), // D24 - PD5 | |||
_BV(7), // D25 / D6 - A7 - PD7 | |||
_BV(4), // D26 / D8 - A8 - PB4 | |||
_BV(5), // D27 / D9 - A9 - PB5 | |||
_BV(6), // D28 / D10 - A10 - PB6 | |||
_BV(6), // D29 / D12 - A11 - PD6 | |||
}; | |||
const uint8_t PROGMEM digital_pin_to_timer_PGM[] = { | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
TIMER0B, /* 3 */ | |||
NOT_ON_TIMER, | |||
TIMER3A, /* 5 */ | |||
TIMER4D, /* 6 */ | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
TIMER1A, /* 9 */ | |||
TIMER1B, /* 10 */ | |||
TIMER0A, /* 11 */ | |||
NOT_ON_TIMER, | |||
TIMER4A, /* 13 */ | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
NOT_ON_TIMER, | |||
}; | |||
const uint8_t PROGMEM analog_pin_to_channel_PGM[] = { | |||
7, // A0 PF7 ADC7 | |||
6, // A1 PF6 ADC6 | |||
5, // A2 PF5 ADC5 | |||
4, // A3 PF4 ADC4 | |||
1, // A4 PF1 ADC1 | |||
0, // A5 PF0 ADC0 | |||
8, // A6 D4 PD4 ADC8 | |||
10, // A7 D6 PD7 ADC10 | |||
11, // A8 D8 PB4 ADC11 | |||
12, // A9 D9 PB5 ADC12 | |||
13, // A10 D10 PB6 ADC13 | |||
9 // A11 D12 PD6 ADC9 | |||
}; | |||
#endif /* ARDUINO_MAIN */ | |||
// These serial port names are intended to allow libraries and architecture-neutral | |||
// sketches to automatically default to the correct port name for a particular type | |||
// of use. For example, a GPS module would normally connect to SERIAL_PORT_HARDWARE_OPEN, | |||
// the first hardware serial port whose RX/TX pins are not dedicated to another use. | |||
// | |||
// SERIAL_PORT_MONITOR Port which normally prints to the Arduino Serial Monitor | |||
// | |||
// SERIAL_PORT_USBVIRTUAL Port which is USB virtual serial | |||
// | |||
// SERIAL_PORT_LINUXBRIDGE Port which connects to a Linux system via Bridge library | |||
// | |||
// SERIAL_PORT_HARDWARE Hardware serial port, physical RX & TX pins. | |||
// | |||
// SERIAL_PORT_HARDWARE_OPEN Hardware serial ports which are open for use. Their RX & TX | |||
// pins are NOT connected to anything by default. | |||
#define SERIAL_PORT_MONITOR Serial | |||
#define SERIAL_PORT_USBVIRTUAL Serial | |||
#define SERIAL_PORT_HARDWARE Serial1 | |||
#define SERIAL_PORT_HARDWARE_OPEN Serial1 | |||
#endif /* Pins_Arduino_h */ |
@ -1,470 +0,0 @@ | |||
#ifdef SSD1306OLED | |||
#include "ssd1306.h" | |||
#include "config.h" | |||
#include "i2c.h" | |||
#include <string.h> | |||
#include "print.h" | |||
#include "lets_split.h" | |||
#include "common/glcdfont.c" | |||
#ifdef ADAFRUIT_BLE_ENABLE | |||
#include "adafruit_ble.h" | |||
#endif | |||
#ifdef PROTOCOL_LUFA | |||
#include "lufa.h" | |||
#endif | |||
#include "sendchar.h" | |||
#include "pincontrol.h" | |||
//assign the right code to your layers | |||
#define _BASE 0 | |||
#define _LOWER 8 | |||
#define _RAISE 16 | |||
#define _FNLAYER 64 | |||
#define _NUMLAY 128 | |||
#define _NLOWER 136 | |||
#define _NFNLAYER 192 | |||
#define _MOUSECURSOR 256 | |||
#define _ADJUST 65560 | |||
// Set this to 1 to help diagnose early startup problems | |||
// when testing power-on with ble. Turn it off otherwise, | |||
// as the latency of printing most of the debug info messes | |||
// with the matrix scan, causing keys to drop. | |||
#define DEBUG_TO_SCREEN 0 | |||
// Controls the SSD1306 128x32 OLED display via i2c | |||
#define i2cAddress 0x3C | |||
#define DisplayHeight 32 | |||
#define DisplayWidth 128 | |||
#define FontHeight 8 | |||
#define FontWidth 6 | |||
#define MatrixRows (DisplayHeight / FontHeight) | |||
#define MatrixCols (DisplayWidth / FontWidth) | |||
struct CharacterMatrix { | |||
uint8_t display[MatrixRows][MatrixCols]; | |||
uint8_t *cursor; | |||
bool dirty; | |||
}; | |||
static struct CharacterMatrix display; | |||
//static uint16_t last_battery_update; | |||
//static uint32_t vbat; | |||
//#define BatteryUpdateInterval 10000 /* milliseconds */ | |||
#define ScreenOffInterval 300000 /* milliseconds */ | |||
#if DEBUG_TO_SCREEN | |||
static uint8_t displaying; | |||
#endif | |||
static uint16_t last_flush; | |||
enum ssd1306_cmds { | |||
DisplayOff = 0xAE, | |||
DisplayOn = 0xAF, | |||
SetContrast = 0x81, | |||
DisplayAllOnResume = 0xA4, | |||
DisplayAllOn = 0xA5, | |||
NormalDisplay = 0xA6, | |||
InvertDisplay = 0xA7, | |||
SetDisplayOffset = 0xD3, | |||
SetComPins = 0xda, | |||
SetVComDetect = 0xdb, | |||
SetDisplayClockDiv = 0xD5, | |||
SetPreCharge = 0xd9, | |||
SetMultiPlex = 0xa8, | |||
SetLowColumn = 0x00, | |||
SetHighColumn = 0x10, | |||
SetStartLine = 0x40, | |||
SetMemoryMode = 0x20, | |||
ColumnAddr = 0x21, | |||
PageAddr = 0x22, | |||
ComScanInc = 0xc0, | |||
ComScanDec = 0xc8, | |||
SegRemap = 0xa0, | |||
SetChargePump = 0x8d, | |||
ExternalVcc = 0x01, | |||
SwitchCapVcc = 0x02, | |||
ActivateScroll = 0x2f, | |||
DeActivateScroll = 0x2e, | |||
SetVerticalScrollArea = 0xa3, | |||
RightHorizontalScroll = 0x26, | |||
LeftHorizontalScroll = 0x27, | |||
VerticalAndRightHorizontalScroll = 0x29, | |||
VerticalAndLeftHorizontalScroll = 0x2a, | |||
}; | |||
// Write command sequence. | |||
// Returns true on success. | |||
static inline bool _send_cmd1(uint8_t cmd) { | |||
bool res = false; | |||
if (i2c_start_write(i2cAddress)) { | |||
xprintf("failed to start write to %d\n", i2cAddress); | |||
goto done; | |||
} | |||
if (i2c_master_write(0x0 /* command byte follows */)) { | |||
print("failed to write control byte\n"); | |||
goto done; | |||
} | |||
if (i2c_master_write(cmd)) { | |||
xprintf("failed to write command %d\n", cmd); | |||
goto done; | |||
} | |||
res = true; | |||
done: | |||
i2c_master_stop(); | |||
return res; | |||
} | |||
// Write 2-byte command sequence. | |||
// Returns true on success | |||
static inline bool _send_cmd2(uint8_t cmd, uint8_t opr) { | |||
if (!_send_cmd1(cmd)) { | |||
return false; | |||
} | |||
return _send_cmd1(opr); | |||
} | |||
// Write 3-byte command sequence. | |||
// Returns true on success | |||
static inline bool _send_cmd3(uint8_t cmd, uint8_t opr1, uint8_t opr2) { | |||
if (!_send_cmd1(cmd)) { | |||
return false; | |||
} | |||
if (!_send_cmd1(opr1)) { | |||
return false; | |||
} | |||
return _send_cmd1(opr2); | |||
} | |||
#define send_cmd1(c) if (!_send_cmd1(c)) {goto done;} | |||
#define send_cmd2(c,o) if (!_send_cmd2(c,o)) {goto done;} | |||
#define send_cmd3(c,o1,o2) if (!_send_cmd3(c,o1,o2)) {goto done;} | |||
static void matrix_clear(struct CharacterMatrix *matrix); | |||
static void clear_display(void) { | |||
matrix_clear(&display); | |||
// Clear all of the display bits (there can be random noise | |||
// in the RAM on startup) | |||
send_cmd3(PageAddr, 0, (DisplayHeight / 8) - 1); | |||
send_cmd3(ColumnAddr, 0, DisplayWidth - 1); | |||
if (i2c_start_write(i2cAddress)) { | |||
goto done; | |||
} | |||
if (i2c_master_write(0x40)) { | |||
// Data mode | |||
goto done; | |||
} | |||
for (uint8_t row = 0; row < MatrixRows; ++row) { | |||
for (uint8_t col = 0; col < DisplayWidth; ++col) { | |||
i2c_master_write(0); | |||
} | |||
} | |||
display.dirty = false; | |||
done: | |||
i2c_master_stop(); | |||
} | |||
#if DEBUG_TO_SCREEN | |||
#undef sendchar | |||
static int8_t capture_sendchar(uint8_t c) { | |||
sendchar(c); | |||
iota_gfx_write_char(c); | |||
if (!displaying) { | |||
iota_gfx_flush(); | |||
} | |||
return 0; | |||
} | |||
#endif | |||
bool iota_gfx_init(void) { | |||
bool success = false; | |||
send_cmd1(DisplayOff); | |||
send_cmd2(SetDisplayClockDiv, 0x80); | |||
send_cmd2(SetMultiPlex, DisplayHeight - 1); | |||
send_cmd2(SetDisplayOffset, 0); | |||
send_cmd1(SetStartLine | 0x0); | |||
send_cmd2(SetChargePump, 0x14 /* Enable */); | |||
send_cmd2(SetMemoryMode, 0 /* horizontal addressing */); | |||
/// Flips the display orientation 0 degrees | |||
send_cmd1(SegRemap | 0x1); | |||
send_cmd1(ComScanDec); | |||
/* | |||
// the following Flip the display orientation 180 degrees | |||
send_cmd1(SegRemap); | |||
send_cmd1(ComScanInc); | |||
// end flip */ | |||
send_cmd2(SetComPins, 0x2); | |||
send_cmd2(SetContrast, 0x8f); | |||
send_cmd2(SetPreCharge, 0xf1); | |||
send_cmd2(SetVComDetect, 0x40); | |||
send_cmd1(DisplayAllOnResume); | |||
send_cmd1(NormalDisplay); | |||
send_cmd1(DeActivateScroll); | |||
send_cmd1(DisplayOn); | |||
send_cmd2(SetContrast, 0); // Dim | |||
clear_display(); | |||
success = true; | |||
iota_gfx_flush(); | |||
#if DEBUG_TO_SCREEN | |||
print_set_sendchar(capture_sendchar); | |||
#endif | |||
done: | |||
return success; | |||
} | |||
bool iota_gfx_off(void) { | |||
bool success = false; | |||
send_cmd1(DisplayOff); | |||
success = true; | |||
done: | |||
return success; | |||
} | |||
bool iota_gfx_on(void) { | |||
bool success = false; | |||
send_cmd1(DisplayOn); | |||
success = true; | |||
done: | |||
return success; | |||
} | |||
static void matrix_write_char_inner(struct CharacterMatrix *matrix, uint8_t c) { | |||
*matrix->cursor = c; | |||
++matrix->cursor; | |||
if (matrix->cursor - &matrix->display[0][0] == sizeof(matrix->display)) { | |||
// We went off the end; scroll the display upwards by one line | |||
memmove(&matrix->display[0], &matrix->display[1], | |||
MatrixCols * (MatrixRows - 1)); | |||
matrix->cursor = &matrix->display[MatrixRows - 1][0]; | |||
memset(matrix->cursor, ' ', MatrixCols); | |||
} | |||
} | |||
static void matrix_write_char(struct CharacterMatrix *matrix, uint8_t c) { | |||
matrix->dirty = true; | |||
if (c == '\n') { | |||
// Clear to end of line from the cursor and then move to the | |||
// start of the next line | |||
uint8_t cursor_col = (matrix->cursor - &matrix->display[0][0]) % MatrixCols; | |||
while (cursor_col++ < MatrixCols) { | |||
matrix_write_char_inner(matrix, ' '); | |||
} | |||
return; | |||
} | |||
matrix_write_char_inner(matrix, c); | |||
} | |||
void iota_gfx_write_char(uint8_t c) { | |||
matrix_write_char(&display, c); | |||
} | |||
static void matrix_write(struct CharacterMatrix *matrix, const char *data) { | |||
const char *end = data + strlen(data); | |||
while (data < end) { | |||
matrix_write_char(matrix, *data); | |||
++data; | |||
} | |||
} | |||
void iota_gfx_write(const char *data) { | |||
matrix_write(&display, data); | |||
} | |||
static void matrix_write_P(struct CharacterMatrix *matrix, const char *data) { | |||
while (true) { | |||
uint8_t c = pgm_read_byte(data); | |||
if (c == 0) { | |||
return; | |||
} | |||
matrix_write_char(matrix, c); | |||
++data; | |||
} | |||
} | |||
void iota_gfx_write_P(const char *data) { | |||
matrix_write_P(&display, data); | |||
} | |||
static void matrix_clear(struct CharacterMatrix *matrix) { | |||
memset(matrix->display, ' ', sizeof(matrix->display)); | |||
matrix->cursor = &matrix->display[0][0]; | |||
matrix->dirty = true; | |||
} | |||
void iota_gfx_clear_screen(void) { | |||
matrix_clear(&display); | |||
} | |||
static void matrix_render(struct CharacterMatrix *matrix) { | |||
last_flush = timer_read(); | |||
iota_gfx_on(); | |||
#if DEBUG_TO_SCREEN | |||
++displaying; | |||
#endif | |||
// Move to the home position | |||
send_cmd3(PageAddr, 0, MatrixRows - 1); | |||
send_cmd3(ColumnAddr, 0, (MatrixCols * FontWidth) - 1); | |||
if (i2c_start_write(i2cAddress)) { | |||
goto done; | |||
} | |||
if (i2c_master_write(0x40)) { | |||
// Data mode | |||
goto done; | |||
} | |||
for (uint8_t row = 0; row < MatrixRows; ++row) { | |||
for (uint8_t col = 0; col < MatrixCols; ++col) { | |||
const uint8_t *glyph = font + (matrix->display[row][col] * (FontWidth - 1)); | |||
for (uint8_t glyphCol = 0; glyphCol < FontWidth - 1; ++glyphCol) { | |||
uint8_t colBits = pgm_read_byte(glyph + glyphCol); | |||
i2c_master_write(colBits); | |||
} | |||
// 1 column of space between chars (it's not included in the glyph) | |||
i2c_master_write(0); | |||
} | |||
} | |||
matrix->dirty = false; | |||
done: | |||
i2c_master_stop(); | |||
#if DEBUG_TO_SCREEN | |||
--displaying; | |||
#endif | |||
} | |||
void iota_gfx_flush(void) { | |||
matrix_render(&display); | |||
} | |||
static void matrix_update(struct CharacterMatrix *dest, | |||
const struct CharacterMatrix *source) { | |||
if (memcmp(dest->display, source->display, sizeof(dest->display))) { | |||
memcpy(dest->display, source->display, sizeof(dest->display)); | |||
dest->dirty = true; | |||
} | |||
} | |||
static void render_status_info(void) { | |||
#if DEBUG_TO_SCREEN | |||
if (debug_enable) { | |||
return; | |||
} | |||
#endif | |||
struct CharacterMatrix matrix; | |||
matrix_clear(&matrix); | |||
matrix_write_P(&matrix, PSTR("USB: ")); | |||
#ifdef PROTOCOL_LUFA | |||
switch (USB_DeviceState) { | |||
case DEVICE_STATE_Unattached: | |||
matrix_write_P(&matrix, PSTR("Unattached")); | |||
break; | |||
case DEVICE_STATE_Suspended: | |||
matrix_write_P(&matrix, PSTR("Suspended")); | |||
break; | |||
case DEVICE_STATE_Configured: | |||
matrix_write_P(&matrix, PSTR("Connected")); | |||
break; | |||
case DEVICE_STATE_Powered: | |||
matrix_write_P(&matrix, PSTR("Powered")); | |||
break; | |||
case DEVICE_STATE_Default: | |||
matrix_write_P(&matrix, PSTR("Default")); | |||
break; | |||
case DEVICE_STATE_Addressed: | |||
matrix_write_P(&matrix, PSTR("Addressed")); | |||
break; | |||
default: | |||
matrix_write_P(&matrix, PSTR("Invalid")); | |||
} | |||
#endif | |||
// Define layers here, Have not worked out how to have text displayed for each layer. Copy down the number you see and add a case for it below | |||
char buf[40]; | |||
snprintf(buf,sizeof(buf), "Undef-%ld", layer_state); | |||
matrix_write_P(&matrix, PSTR("\n\nLayer: ")); | |||
switch (layer_state) { | |||
case _BASE: | |||
matrix_write_P(&matrix, PSTR("Default")); | |||
break; | |||
case _RAISE: | |||
matrix_write_P(&matrix, PSTR("Raise")); | |||
break; | |||
case _LOWER: | |||
matrix_write_P(&matrix, PSTR("Lower")); | |||
break; | |||
case _ADJUST: | |||
matrix_write_P(&matrix, PSTR("ADJUST")); | |||
break; | |||
default: | |||
matrix_write(&matrix, buf); | |||
} | |||
// Host Keyboard LED Status | |||
char led[40]; | |||
snprintf(led, sizeof(led), "\n%s %s %s", | |||
(host_keyboard_leds() & (1<<USB_LED_NUM_LOCK)) ? "NUMLOCK" : " ", | |||
(host_keyboard_leds() & (1<<USB_LED_CAPS_LOCK)) ? "CAPS" : " ", | |||
(host_keyboard_leds() & (1<<USB_LED_SCROLL_LOCK)) ? "SCLK" : " "); | |||
matrix_write(&matrix, led); | |||
matrix_update(&display, &matrix); | |||
} | |||
void iota_gfx_task(void) { | |||
render_status_info(); | |||
if (display.dirty) { | |||
iota_gfx_flush(); | |||
} | |||
if (timer_elapsed(last_flush) > ScreenOffInterval) { | |||
iota_gfx_off(); | |||
} | |||
} | |||
#endif |
@ -1,17 +0,0 @@ | |||
#ifndef SSD1306_H | |||
#define SSD1306_H | |||
#include <stdbool.h> | |||
#include <stdio.h> | |||
bool iota_gfx_init(void); | |||
void iota_gfx_task(void); | |||
bool iota_gfx_off(void); | |||
bool iota_gfx_on(void); | |||
void iota_gfx_flush(void); | |||
void iota_gfx_write_char(uint8_t c); | |||
void iota_gfx_write(const char *data); | |||
void iota_gfx_write_P(const char *data); | |||
void iota_gfx_clear_screen(void); | |||
#endif |
@ -1,128 +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 "animations.h" | |||
#include "visualizer.h" | |||
#ifdef BACKLIGHT_ENABLE | |||
#include "led_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 BACKLIGHT_ENABLE | |||
led_keyframe_enable(animation, state); | |||
#endif | |||
return false; | |||
} | |||
static bool keyframe_disable(keyframe_animation_t* animation, visualizer_state_t* state) { | |||
#ifdef BACKLIGHT_ENABLE | |||
led_keyframe_disable(animation, state); | |||
#endif | |||
return false; | |||
} | |||
static bool keyframe_fade_in(keyframe_animation_t* animation, visualizer_state_t* state) { | |||
bool ret = false; | |||
#ifdef BACKLIGHT_ENABLE | |||
ret |= led_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 BACKLIGHT_ENABLE | |||
ret |= led_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 = { | |||
.num_frames = 2, | |||
.loop = false, | |||
.frame_lengths = {0, gfxMillisecondsToTicks(5000)}, | |||
.frame_functions = { | |||
keyframe_enable, | |||
keyframe_fade_in, | |||
}, | |||
}; | |||
keyframe_animation_t default_suspend_animation = { | |||
.num_frames = 2, | |||
.loop = false, | |||
.frame_lengths = {gfxMillisecondsToTicks(1000), 0}, | |||
.frame_functions = { | |||
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_keyframe_fade_in_all, | |||
keyframe_no_operation, | |||
led_keyframe_fade_out_all, | |||
led_keyframe_crossfade, | |||
led_keyframe_left_to_right_gradient, | |||
led_keyframe_crossfade, | |||
led_keyframe_top_to_bottom_gradient, | |||
led_keyframe_mirror_orientation, | |||
led_keyframe_crossfade, | |||
led_keyframe_left_to_right_gradient, | |||
led_keyframe_crossfade, | |||
led_keyframe_top_to_bottom_gradient, | |||
led_keyframe_normal_orientation, | |||
led_keyframe_crossfade, | |||
}, | |||
}; | |||
#endif | |||
#endif |
@ -1,2 +0,0 @@ | |||
GFXINC += drivers/gdisp/IS31FL3731C | |||
GFXSRC += drivers/gdisp/IS31FL3731C/gdisp_IS31FL3731C.c |
@ -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 TRUE // This controller requires flushing | |||
#define GDISP_HARDWARE_DRAWPIXEL TRUE | |||
#define GDISP_HARDWARE_PIXELREAD TRUE | |||
#define GDISP_HARDWARE_CONTROL TRUE | |||
#define GDISP_LLD_PIXELFORMAT GDISP_PIXELFORMAT_GRAY256 | |||
#endif /* GFX_USE_GDISP */ | |||
#endif /* _GDISP_LLD_CONFIG_H */ |
@ -0,0 +1,325 @@ | |||
/** | |||
* 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 COMMON_GFXCONF_H | |||
#define COMMON_GFXCONF_H | |||
/////////////////////////////////////////////////////////////////////////// | |||
// GOS - One of these must be defined, preferably in your Makefile // | |||
/////////////////////////////////////////////////////////////////////////// | |||
//#define GFX_USE_OS_CHIBIOS TRUE | |||
//#define GFX_USE_OS_FREERTOS FALSE | |||
// #define GFX_FREERTOS_USE_TRACE FALSE | |||
//#define GFX_USE_OS_WIN32 FALSE | |||
//#define GFX_USE_OS_LINUX FALSE | |||
//#define GFX_USE_OS_OSX FALSE | |||
//#define GFX_USE_OS_ECOS FALSE | |||
//#define GFX_USE_OS_RAWRTOS FALSE | |||
//#define GFX_USE_OS_ARDUINO FALSE | |||
//#define GFX_USE_OS_KEIL FALSE | |||
//#define GFX_USE_OS_CMSIS FALSE | |||
//#define GFX_USE_OS_RAW32 FALSE | |||
// #define INTERRUPTS_OFF() optional_code | |||
// #define INTERRUPTS_ON() optional_code | |||
// These are not defined by default for some reason | |||
#define GOS_NEED_X_THREADS FALSE | |||
#define GOS_NEED_X_HEAP FALSE | |||
// Options that (should where relevant) apply to all operating systems | |||
#define GFX_NO_INLINE FALSE | |||
// #define GFX_COMPILER GFX_COMPILER_UNKNOWN | |||
// #define GFX_CPU GFX_CPU_UNKNOWN | |||
// #define GFX_OS_HEAP_SIZE 0 | |||
// #define GFX_OS_NO_INIT FALSE | |||
// #define GFX_OS_INIT_NO_WARNING FALSE | |||
// #define GFX_OS_PRE_INIT_FUNCTION myHardwareInitRoutine | |||
// #define GFX_OS_EXTRA_INIT_FUNCTION myOSInitRoutine | |||
// #define GFX_OS_EXTRA_DEINIT_FUNCTION myOSDeInitRoutine | |||
/////////////////////////////////////////////////////////////////////////// | |||
// GDISP // | |||
/////////////////////////////////////////////////////////////////////////// | |||
#define GFX_USE_GDISP TRUE | |||
//#define GDISP_NEED_AUTOFLUSH FALSE | |||
//#define GDISP_NEED_TIMERFLUSH FALSE | |||
//#define GDISP_NEED_VALIDATION TRUE | |||
//#define GDISP_NEED_CLIP TRUE | |||
#define GDISP_NEED_CIRCLE TRUE | |||
#define GDISP_NEED_ELLIPSE TRUE | |||
#define GDISP_NEED_ARC TRUE | |||
#define GDISP_NEED_ARCSECTORS TRUE | |||
#define GDISP_NEED_CONVEX_POLYGON TRUE | |||
//#define GDISP_NEED_SCROLL FALSE | |||
#define GDISP_NEED_PIXELREAD TRUE | |||
#define GDISP_NEED_CONTROL TRUE | |||
//#define GDISP_NEED_QUERY FALSE | |||
//#define GDISP_NEED_MULTITHREAD FALSE | |||
//#define GDISP_NEED_STREAMING FALSE | |||
#define GDISP_NEED_TEXT TRUE | |||
// #define GDISP_NEED_TEXT_WORDWRAP FALSE | |||
// #define GDISP_NEED_ANTIALIAS FALSE | |||
// #define GDISP_NEED_UTF8 FALSE | |||
#define GDISP_NEED_TEXT_KERNING TRUE | |||
// #define GDISP_INCLUDE_FONT_UI1 FALSE | |||
// #define GDISP_INCLUDE_FONT_UI2 FALSE // The smallest preferred font. | |||
// #define GDISP_INCLUDE_FONT_LARGENUMBERS FALSE | |||
// #define GDISP_INCLUDE_FONT_DEJAVUSANS10 FALSE | |||
// #define GDISP_INCLUDE_FONT_DEJAVUSANS12 FALSE | |||
// #define GDISP_INCLUDE_FONT_DEJAVUSANS16 FALSE | |||
// #define GDISP_INCLUDE_FONT_DEJAVUSANS20 FALSE | |||
// #define GDISP_INCLUDE_FONT_DEJAVUSANS24 FALSE | |||
// #define GDISP_INCLUDE_FONT_DEJAVUSANS32 FALSE | |||
#define GDISP_INCLUDE_FONT_DEJAVUSANSBOLD12 TRUE | |||
// #define GDISP_INCLUDE_FONT_FIXED_10X20 FALSE | |||
// #define GDISP_INCLUDE_FONT_FIXED_7X14 FALSE | |||
#define GDISP_INCLUDE_FONT_FIXED_5X8 TRUE | |||
// #define GDISP_INCLUDE_FONT_DEJAVUSANS12_AA FALSE | |||
// #define GDISP_INCLUDE_FONT_DEJAVUSANS16_AA FALSE | |||
// #define GDISP_INCLUDE_FONT_DEJAVUSANS20_AA FALSE | |||
// #define GDISP_INCLUDE_FONT_DEJAVUSANS24_AA FALSE | |||
// #define GDISP_INCLUDE_FONT_DEJAVUSANS32_AA FALSE | |||
// #define GDISP_INCLUDE_FONT_DEJAVUSANSBOLD12_AA FALSE | |||
// #define GDISP_INCLUDE_USER_FONTS FALSE | |||
//#define GDISP_NEED_IMAGE FALSE | |||
// #define GDISP_NEED_IMAGE_NATIVE FALSE | |||
// #define GDISP_NEED_IMAGE_GIF FALSE | |||
// #define GDISP_NEED_IMAGE_BMP FALSE | |||
// #define GDISP_NEED_IMAGE_BMP_1 FALSE | |||
// #define GDISP_NEED_IMAGE_BMP_4 FALSE | |||
// #define GDISP_NEED_IMAGE_BMP_4_RLE FALSE | |||
// #define GDISP_NEED_IMAGE_BMP_8 FALSE | |||
// #define GDISP_NEED_IMAGE_BMP_8_RLE FALSE | |||
// #define GDISP_NEED_IMAGE_BMP_16 FALSE | |||
// #define GDISP_NEED_IMAGE_BMP_24 FALSE | |||
// #define GDISP_NEED_IMAGE_BMP_32 FALSE | |||
// #define GDISP_NEED_IMAGE_JPG FALSE | |||
// #define GDISP_NEED_IMAGE_PNG FALSE | |||
// #define GDISP_NEED_IMAGE_ACCOUNTING FALSE | |||
#ifdef EMULATOR | |||
#define GDISP_NEED_PIXMAP TRUE | |||
#endif | |||
// #define GDISP_NEED_PIXMAP_IMAGE FALSE | |||
//#define GDISP_DEFAULT_ORIENTATION GDISP_ROTATE_LANDSCAPE // If not defined the native hardware orientation is used. | |||
//#define GDISP_LINEBUF_SIZE 128 | |||
//#define GDISP_STARTUP_COLOR Black | |||
#define GDISP_NEED_STARTUP_LOGO FALSE | |||
//#define GDISP_TOTAL_DISPLAYS 2 | |||
#ifdef GDISP_DRIVER_LIST | |||
// For code and speed optimization define as TRUE or FALSE if all controllers have the same capability | |||
#define GDISP_HARDWARE_STREAM_WRITE FALSE | |||
#define GDISP_HARDWARE_STREAM_READ FALSE | |||
#define GDISP_HARDWARE_STREAM_POS FALSE | |||
#define GDISP_HARDWARE_DRAWPIXEL TRUE | |||
#define GDISP_HARDWARE_CLEARS FALSE | |||
#define GDISP_HARDWARE_FILLS FALSE | |||
//#define GDISP_HARDWARE_BITFILLS FALSE | |||
#define GDISP_HARDWARE_SCROLL FALSE | |||
#define GDISP_HARDWARE_PIXELREAD TRUE | |||
#define GDISP_HARDWARE_CONTROL TRUE | |||
#define GDISP_HARDWARE_QUERY FALSE | |||
#define GDISP_HARDWARE_CLIP FALSE | |||
#define GDISP_PIXELFORMAT GDISP_PIXELFORMAT_RGB888 | |||
#endif | |||
// The custom format is not defined for some reason, so define it as error | |||
// so we don't get compiler warnings | |||
#define GDISP_PIXELFORMAT_CUSTOM GDISP_PIXELFORMAT_ERROR | |||
#define GDISP_USE_GFXNET FALSE | |||
// #define GDISP_GFXNET_PORT 13001 | |||
// #define GDISP_GFXNET_CUSTOM_LWIP_STARTUP FALSE | |||
// #define GDISP_DONT_WAIT_FOR_NET_DISPLAY FALSE | |||
// #define GDISP_GFXNET_UNSAFE_SOCKETS FALSE | |||
/////////////////////////////////////////////////////////////////////////// | |||
// GWIN // | |||
/////////////////////////////////////////////////////////////////////////// | |||
#define GFX_USE_GWIN FALSE | |||
//#define GWIN_NEED_WINDOWMANAGER FALSE | |||
// #define GWIN_REDRAW_IMMEDIATE FALSE | |||
// #define GWIN_REDRAW_SINGLEOP FALSE | |||
// #define GWIN_NEED_FLASHING FALSE | |||
// #define GWIN_FLASHING_PERIOD 250 | |||
//#define GWIN_NEED_CONSOLE FALSE | |||
// #define GWIN_CONSOLE_USE_HISTORY FALSE | |||
// #define GWIN_CONSOLE_HISTORY_AVERAGING FALSE | |||
// #define GWIN_CONSOLE_HISTORY_ATCREATE FALSE | |||
// #define GWIN_CONSOLE_ESCSEQ FALSE | |||
// #define GWIN_CONSOLE_USE_BASESTREAM FALSE | |||
// #define GWIN_CONSOLE_USE_FLOAT FALSE | |||
//#define GWIN_NEED_GRAPH FALSE | |||
//#define GWIN_NEED_GL3D FALSE | |||
//#define GWIN_NEED_WIDGET FALSE | |||
//#define GWIN_FOCUS_HIGHLIGHT_WIDTH 1 | |||
// #define GWIN_NEED_LABEL FALSE | |||
// #define GWIN_LABEL_ATTRIBUTE FALSE | |||
// #define GWIN_NEED_BUTTON FALSE | |||
// #define GWIN_BUTTON_LAZY_RELEASE FALSE | |||
// #define GWIN_NEED_SLIDER FALSE | |||
// #define GWIN_SLIDER_NOSNAP FALSE | |||
// #define GWIN_SLIDER_DEAD_BAND 5 | |||
// #define GWIN_SLIDER_TOGGLE_INC 20 | |||
// #define GWIN_NEED_CHECKBOX FALSE | |||
// #define GWIN_NEED_IMAGE FALSE | |||
// #define GWIN_NEED_IMAGE_ANIMATION FALSE | |||
// #define GWIN_NEED_RADIO FALSE | |||
// #define GWIN_NEED_LIST FALSE | |||
// #define GWIN_NEED_LIST_IMAGES FALSE | |||
// #define GWIN_NEED_PROGRESSBAR FALSE | |||
// #define GWIN_PROGRESSBAR_AUTO FALSE | |||
// #define GWIN_NEED_KEYBOARD FALSE | |||
// #define GWIN_KEYBOARD_DEFAULT_LAYOUT VirtualKeyboard_English1 | |||
// #define GWIN_NEED_KEYBOARD_ENGLISH1 TRUE | |||
// #define GWIN_NEED_TEXTEDIT FALSE | |||
// #define GWIN_FLAT_STYLING FALSE | |||
// #define GWIN_WIDGET_TAGS FALSE | |||
//#define GWIN_NEED_CONTAINERS FALSE | |||
// #define GWIN_NEED_CONTAINER FALSE | |||
// #define GWIN_NEED_FRAME FALSE | |||
// #define GWIN_NEED_TABSET FALSE | |||
// #define GWIN_TABSET_TABHEIGHT 18 | |||
/////////////////////////////////////////////////////////////////////////// | |||
// GEVENT // | |||
/////////////////////////////////////////////////////////////////////////// | |||
#define GFX_USE_GEVENT TRUE | |||
//#define GEVENT_ASSERT_NO_RESOURCE FALSE | |||
//#define GEVENT_MAXIMUM_SIZE 32 | |||
//#define GEVENT_MAX_SOURCE_LISTENERS 32 | |||
/////////////////////////////////////////////////////////////////////////// | |||
// GTIMER // | |||
/////////////////////////////////////////////////////////////////////////// | |||
#define GFX_USE_GTIMER FALSE | |||
//#define GTIMER_THREAD_PRIORITY HIGH_PRIORITY | |||
//#define GTIMER_THREAD_WORKAREA_SIZE 2048 | |||
/////////////////////////////////////////////////////////////////////////// | |||
// GQUEUE // | |||
/////////////////////////////////////////////////////////////////////////// | |||
#define GFX_USE_GQUEUE FALSE | |||
//#define GQUEUE_NEED_ASYNC FALSE | |||
//#define GQUEUE_NEED_GSYNC FALSE | |||
//#define GQUEUE_NEED_FSYNC FALSE | |||
//#define GQUEUE_NEED_BUFFERS FALSE | |||
/////////////////////////////////////////////////////////////////////////// | |||
// GINPUT // | |||
/////////////////////////////////////////////////////////////////////////// | |||
#define GFX_USE_GINPUT FALSE | |||
//#define GINPUT_NEED_MOUSE FALSE | |||
// #define GINPUT_TOUCH_STARTRAW FALSE | |||
// #define GINPUT_TOUCH_NOTOUCH FALSE | |||
// #define GINPUT_TOUCH_NOCALIBRATE FALSE | |||
// #define GINPUT_TOUCH_NOCALIBRATE_GUI FALSE | |||
// #define GINPUT_MOUSE_POLL_PERIOD 25 | |||
// #define GINPUT_MOUSE_CLICK_TIME 300 | |||
// #define GINPUT_TOUCH_CXTCLICK_TIME 700 | |||
// #define GINPUT_TOUCH_USER_CALIBRATION_LOAD FALSE | |||
// #define GINPUT_TOUCH_USER_CALIBRATION_SAVE FALSE | |||
// #define GMOUSE_DRIVER_LIST GMOUSEVMT_Win32, GMOUSEVMT_Win32 | |||
//#define GINPUT_NEED_KEYBOARD FALSE | |||
// #define GINPUT_KEYBOARD_POLL_PERIOD 200 | |||
// #define GKEYBOARD_DRIVER_LIST GKEYBOARDVMT_Win32, GKEYBOARDVMT_Win32 | |||
// #define GKEYBOARD_LAYOUT_OFF FALSE | |||
// #define GKEYBOARD_LAYOUT_SCANCODE2_US FALSE | |||
//#define GINPUT_NEED_TOGGLE FALSE | |||
//#define GINPUT_NEED_DIAL FALSE | |||
/////////////////////////////////////////////////////////////////////////// | |||
// GFILE // | |||
/////////////////////////////////////////////////////////////////////////// | |||
#define GFX_USE_GFILE FALSE | |||
//#define GFILE_NEED_PRINTG FALSE | |||
//#define GFILE_NEED_SCANG FALSE | |||
//#define GFILE_NEED_STRINGS FALSE | |||
//#define GFILE_NEED_FILELISTS FALSE | |||
//#define GFILE_NEED_STDIO FALSE | |||
//#define GFILE_NEED_NOAUTOMOUNT FALSE | |||
//#define GFILE_NEED_NOAUTOSYNC FALSE | |||
//#define GFILE_NEED_MEMFS FALSE | |||
//#define GFILE_NEED_ROMFS FALSE | |||
//#define GFILE_NEED_RAMFS FALSE | |||
//#define GFILE_NEED_FATFS FALSE | |||
//#define GFILE_NEED_NATIVEFS FALSE | |||
//#define GFILE_NEED_CHBIOSFS FALSE | |||
//#define GFILE_ALLOW_FLOATS FALSE | |||
//#define GFILE_ALLOW_DEVICESPECIFIC FALSE | |||
//#define GFILE_MAX_GFILES 3 | |||
/////////////////////////////////////////////////////////////////////////// | |||
// GADC // | |||
/////////////////////////////////////////////////////////////////////////// | |||
#define GFX_USE_GADC FALSE | |||
//#define GADC_MAX_LOWSPEED_DEVICES 4 | |||
/////////////////////////////////////////////////////////////////////////// | |||
// GAUDIO // | |||
/////////////////////////////////////////////////////////////////////////// | |||
#define GFX_USE_GAUDIO FALSE | |||
// There seems to be a bug in the ugfx code, the wrong define is used | |||
// So define it in order to avoid warnings | |||
#define GFX_USE_GAUDIN GFX_USE_GAUDIO | |||
// #define GAUDIO_NEED_PLAY FALSE | |||
// #define GAUDIO_NEED_RECORD FALSE | |||
/////////////////////////////////////////////////////////////////////////// | |||
// GMISC // | |||
/////////////////////////////////////////////////////////////////////////// | |||
#define GFX_USE_GMISC TRUE | |||
//#define GMISC_NEED_ARRAYOPS FALSE | |||
//#define GMISC_NEED_FASTTRIG FALSE | |||
//#define GMISC_NEED_FIXEDTRIG FALSE | |||
//#define GMISC_NEED_INVSQRT FALSE | |||
// #define GMISC_INVSQRT_MIXED_ENDIAN FALSE | |||
// #define GMISC_INVSQRT_REAL_SLOW FALSE | |||
#define GMISC_NEED_MATRIXFLOAT2D TRUE | |||
#define GMISC_NEED_MATRIXFIXED2D FALSE | |||
#endif /* COMMON_GFXCONF_H */ |