Cons-n-Stuff/iidx_pico
1
0
Fork 0
mirror of https://github.com/whowechina/iidx_pico.git synced 2025-02-26 06:39:41 +01:00
Code Releases Activity

Big update on firmware

Browse Source
This commit is contained in:
whowechina 2023-04-09 07:23:26 +08:00
parent 040175f296
commit 10e99e362a
15 changed files with 408 additions and 392 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
firmware/src/board_defs.h
View File

@ -4,23 +4,8 @@
*/
#if defined BOARD_IIDX_PICO
/* A button consists of a switch and an LED
7 main buttons + E1, E2, E3, E4 */
#define BUTTON_DEF { \
{8, -1}, \
{7, -1}, \
{6, -1}, \
{5, -1}, \
{4, -1}, \
{3, -1}, \
{2, -1}, \
{12, -1}, \
{11, -1}, \
{10, -1}, \
{9, -1}, \
{1, -1}, \
{0, -1}, \
}
/* List of button pins */
#define BUTTON_DEF { 8, 7, 6, 5, 4, 3, 2, 12, 11, 10, 9, 1, 0 }
#define BUTTON_RGB_PIN 13
#define BUTTON_RGB_NUM 11
@ -31,13 +16,8 @@
#define BUTTON_RGB_ORDER GRB
#define TT_RGB_PIN 28
#define TT_RGB_NUM 52
#define TT_RGB_ORDER GRB
#define TT_RGB_START 0
#define TT_RGB_SIZE 52
#define TT_RGB_REVERSED true
#define TT_AS5600_SCL 27
#define TT_AS5600_SDA 26
#define TT_AS5600_I2C i2c1

286
firmware/src/buttons.c
View File

@ -10,99 +10,30 @@
#include <stdint.h>
#include <stdbool.h>
#include "bsp/board.h"
#include "hardware/gpio.h"
#include "hardware/timer.h"
#include "hardware/pwm.h"
#include "rgb.h"
#include "config.h"
#include "board_defs.h"
#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
static const struct button {
int8_t sw_gpio;
int8_t led_gpio; /* led related to the button */
} BUTTON_DEFS[] = BUTTON_DEF;
#define BUTTON_NUM (ARRAY_SIZE(BUTTON_DEFS))
#define AUX_1 (BUTTON_NUM - 2)
#define AUX_2 (BUTTON_NUM - 1)
static const uint8_t BUTTON_GPIOS[] = BUTTON_DEF;
#define BUTTON_NUM (sizeof(BUTTON_GPIOS))
static bool sw_val[BUTTON_NUM]; /* true if pressed */
static uint64_t sw_freeze_time[BUTTON_NUM];
typedef struct {
uint8_t led_level;
uint8_t rgb_level;
uint8_t up_speed;
uint8_t down_speed;
} button_cfg_t;
static button_cfg_t *cfg;
#define LIMIT_MAX(a, max, def) { if (a > max) a = def; }
static void cfg_loaded()
{
LIMIT_MAX(cfg->led_level, 8, 8);
LIMIT_MAX(cfg->rgb_level, 8, 8);
LIMIT_MAX(cfg->up_speed, 2, 0);
LIMIT_MAX(cfg->down_speed, 3, 0);
rgb_set_level(cfg->rgb_level);
config_request_save();
}
static void init_cfg()
{
button_cfg_t def = {8, 8, 0, 0};
cfg = (button_cfg_t *)config_alloc(sizeof(def), &def, cfg_loaded);
}
static uint16_t alpha[256];
static void init_alpha()
{
for (int i = 0; i < 256; i++) {
alpha[i] = (i + 1) * (i + 1) - 1;
}
}
static void init_switch()
{
for (int i = 0; i < BUTTON_NUM; i++)
{
sw_val[i] = false;
sw_freeze_time[i] = 0;
int8_t gpio = BUTTON_DEFS[i].sw_gpio;
gpio_init(gpio);
gpio_set_function(gpio, GPIO_FUNC_SIO);
gpio_set_dir(BUTTON_DEFS[i].sw_gpio, GPIO_IN);
gpio_pull_up(BUTTON_DEFS[i].sw_gpio);
}
}
static void init_led()
{
for (int i = 0; i < BUTTON_NUM; i++)
{
int8_t gpio = BUTTON_DEFS[i].led_gpio;
if (gpio >= 0) {
gpio_set_function(gpio, GPIO_FUNC_PWM);
uint slice = pwm_gpio_to_slice_num(gpio);
pwm_config cfg = pwm_get_default_config();
pwm_config_set_clkdiv(&cfg, 4.f);
pwm_init(slice, &cfg, true);
}
}
}
void button_init()
{
init_cfg();
init_alpha();
init_switch();
init_led();
for (int i = 0; i < BUTTON_NUM; i++) {
sw_val[i] = false;
sw_freeze_time[i] = 0;
int8_t gpio = BUTTON_GPIOS[i];
gpio_init(gpio);
gpio_set_function(gpio, GPIO_FUNC_SIO);
gpio_set_dir(gpio, GPIO_IN);
gpio_pull_up(gpio);
}
}
uint8_t button_num()
@ -112,18 +43,9 @@ uint8_t button_num()
uint8_t button_gpio(uint8_t id)
{
return BUTTON_DEFS[id].sw_gpio;
return BUTTON_GPIOS[id];
}
typedef enum {
NORMAL,
SET_LED_LEVEL,
SET_RGB_LEVEL,
SET_FADING_LEVEL,
} mode_t;
mode_t run_mode = NORMAL;
/* If a switch flips, it freezes for a while */
#define DEBOUNCE_FREEZE_TIME_US 1000
uint16_t button_read()
@ -132,7 +54,7 @@ uint16_t button_read()
uint16_t buttons = 0;
for (int i = BUTTON_NUM - 1; i >= 0; i--) {
bool sw_pressed = !gpio_get(BUTTON_DEFS[i].sw_gpio);
bool sw_pressed = !gpio_get(BUTTON_GPIOS[i]);
if (now >= sw_freeze_time[i]) {
if (sw_pressed != sw_val[i]) {
@ -147,183 +69,5 @@ uint16_t button_read()
}
}
/* Hide 9 main button signals while in setting mode */
return run_mode == NORMAL ? buttons : (buttons & 0xFE00);
}
#define HID_EXPIRE_DURATION 1000000ULL
static uint32_t hid_expire_time = 0;
static bool hid_lights[BUTTON_NUM];
static bool led_on[BUTTON_NUM];
static uint8_t led_pwm[BUTTON_NUM];
static const uint8_t level_val[9] = {0, 33, 77, 117, 150, 180, 205, 230, 255};
static const uint8_t up_cycles[4] = {1, 20, 40, 60};
static const uint8_t down_cycles[5] = {1, 32, 64, 96, 128};
static void drive_led_pwm()
{
for (int i = 0; i < BUTTON_NUM; i++) {
if (BUTTON_DEFS[i].led_gpio >= 0) {
pwm_set_gpio_level(BUTTON_DEFS[i].led_gpio, alpha[led_pwm[i]]);
}
}
}
static void run_led_fade()
{
static uint32_t up_cnt = 0;
static uint32_t down_cnt = 0;
uint32_t up_cycle = up_cycles[cfg->up_speed] * (9 - cfg->led_level);
uint32_t down_cycle = down_cycles[cfg->down_speed] * (9 - cfg->led_level);
up_cnt = (up_cnt + 1) % up_cycle;
down_cnt = (down_cnt + 1) % down_cycle;
for (int i = 0; i < BUTTON_NUM; i++) {
uint8_t target = led_on[i] ? level_val[cfg->led_level] : 0;
if ((target > led_pwm[i]) && (up_cnt == 0)) {
led_pwm[i]++;
} else if ((target < led_pwm[i]) && (down_cnt == 0)) {
led_pwm[i]--;
}
/* quickly limit led level */
if (led_pwm[i] > level_val[cfg->led_level]) {
led_pwm[i] = level_val[cfg->led_level];
}
}
}
static void led_demo(bool reset)
{
static uint32_t loop = 0;
if (reset) {
loop = 0;
return;
}
loop = (loop + 1) % 0x24000;
bool is_on = (loop < 0x12000);
for (int i = 0; i < 9; i++) {
led_on[i] = is_on;
}
}
static void led_indicate(uint8_t id)
{
static uint32_t loop = 0;
loop = (loop + 1) % 0x2000;
led_pwm[id] = (loop & 0x1000) > 0 ? 200 : 0;
}
static void update_mode()
{
mode_t new_mode;
if (sw_val[AUX_1] && !sw_val[AUX_2]) {
new_mode = SET_LED_LEVEL;
} else if (!sw_val[AUX_1] && sw_val[AUX_2]) {
new_mode = SET_RGB_LEVEL;
} else if (sw_val[AUX_1] && sw_val[AUX_2]) {
new_mode = SET_FADING_LEVEL;
} else {
new_mode = NORMAL;
}
if (new_mode != run_mode) {
run_mode = new_mode;
led_demo(true);
}
}
static void run_normal()
{
bool hid_active = (time_us_64() < hid_expire_time);
for (int i = 0; i < BUTTON_NUM; i++) {
led_on[i] = hid_active ? hid_lights[i] : sw_val[i];
}
}
static void read_value(uint8_t *value)
{
for (int i = 0; i < 9; i++) {
if (sw_val[i]) {
*value = i;
config_request_save();
led_demo(true);
break;
}
}
}
static void run_led_setup()
{
read_value(&cfg->led_level);
led_demo(false);
led_indicate(cfg->led_level);
}
static void run_rgb_setup()
{
read_value(&cfg->rgb_level);
rgb_set_level(cfg->rgb_level);
led_indicate(cfg->rgb_level);
}
static void get_fade_value()
{
for (int i = 0; i < 9; i++) {
if (sw_val[i]) {
if (i % 2 == 0) {
cfg->down_speed = i / 2;
} else {
cfg->up_speed = (i - 1) / 2;
}
config_request_save();
led_demo(true);
return;
}
}
}
static void run_fading_setup()
{
get_fade_value();
led_demo(false);
led_indicate(cfg->up_speed * 2 + 1);
led_indicate(cfg->down_speed * 2);
}
static void proc_mode()
{
switch(run_mode) {
case NORMAL:
run_normal();
break;
case SET_LED_LEVEL:
run_led_setup();
break;
case SET_RGB_LEVEL:
run_rgb_setup();
break;
case SET_FADING_LEVEL:
run_fading_setup();
break;
}
}
void button_update()
{
run_led_fade();
update_mode();
proc_mode();
drive_led_pwm();
}
void button_set_hid_light(uint8_t const *lights, uint8_t num)
{
for (int i = 0; (i < num) && (i < BUTTON_NUM); i++) {
hid_lights[i] = (lights[i] > 0);
}
hid_expire_time = time_us_64() + HID_EXPIRE_DURATION;
return buttons;
}

5
firmware/src/buttons.h
View File

@ -7,8 +7,6 @@
#define BUTTONS_H
#include <stdint.h>
#include <stdbool.h>
#include "hardware/flash.h"
void button_init();
uint8_t button_num();
@ -16,7 +14,4 @@ uint8_t button_gpio(uint8_t id);
uint16_t button_read();
void button_update();
void button_set_hid_light(uint8_t const *lights, uint8_t num);
#endif

1
firmware/src/config.c
View File

@ -8,6 +8,7 @@
#include "config.h"
#include <stdint.h>
#include <stdlib.h>
#include <stdbool.h>
#include <memory.h>

60
firmware/src/main.c
View File

@ -3,7 +3,6 @@
* WHowe <github.com/whowechina>
*/
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
@ -15,6 +14,8 @@
#include "tusb.h"
#include "usb_descriptors.h"
#include "setup.h"
#include "buttons.h"
#include "rgb.h"
#include "turntable.h"
@ -24,33 +25,32 @@
#include "config.h"
/* Measure the time of a function call */
#define RUN_TIME(func) \
{ uint64_t _t = time_us_64(); func; \
printf(#func ":%lld\n", time_us_64() - _t); }
struct report
{
struct {
uint16_t buttons;
uint8_t joy0;
uint8_t joy1;
} report;
uint8_t joy[6];
} hid_report;
void hid_report()
void report_usb_hid()
{
if (tud_hid_ready())
{
report.joy1 = 0;
tud_hid_n_report(0x00, REPORT_ID_JOYSTICK, &report, sizeof(report));
if (tud_hid_ready()) {
hid_report.joy[2] = iidx_cfg.effects.play_vol;
hid_report.joy[3] = iidx_cfg.effects.filter;
hid_report.joy[4] = iidx_cfg.effects.eq_low;
hid_report.joy[5] = iidx_cfg.effects.eq_hi;
tud_hid_n_report(0x00, REPORT_ID_JOYSTICK, &hid_report, sizeof(hid_report));
}
}
void boot_check()
{
uint64_t key1 = (1 << (button_num() - 1));
uint64_t key2 = (1 << (button_num() - 2));
uint64_t buttons = button_read();
uint16_t key1 = (1 << (button_num() - 1));
uint16_t key2 = (1 << (button_num() - 2));
uint16_t buttons = button_read();
if ((buttons & key1) && (buttons & key2)) {
reset_usb_boot(button_gpio(button_num() - 1), 2);
}
@ -73,7 +73,8 @@ static void core1_loop()
while (true) {
uint32_t angle = turntable_read();
rgb_set_angle(angle);
report.joy0 = angle >> 4; // 12bit to 8bit
hid_report.joy[0] = angle >> 4; // 12bit to 8bit
hid_report.joy[1] = 255 - hid_report.joy[0];
RUN_EVERY_N_MS(rgb_update(), 2);
turntable_update();
frame++;
@ -88,10 +89,20 @@ static void core0_loop()
while (true)
{
tud_task();
report.buttons = button_read();
hid_report();
rgb_set_button_light(report.buttons);
button_update();
uint16_t buttons = button_read();
uint16_t angle = turntable_read() >> 4;
if (setup_run(buttons, angle)) {
turntable_set_hardware(iidx_cfg.tt_sensor_reversed);
rgb_set_hardware(iidx_cfg.tt_led.start, iidx_cfg.tt_led.num, iidx_cfg.tt_led.reversed);
rgb_force_display(setup_led_button, setup_led_tt);
report_usb_hid();
sleep_ms(5);
continue;
}
hid_report.buttons = buttons;
report_usb_hid();
rgb_set_button_light(buttons);
config_loop();
}
}
@ -100,15 +111,17 @@ void init()
{
board_init();
tusb_init();
button_init();
button_init();
tt_rainbow_init();
tt_blade_init();
rgb_init();
turntable_init();
boot_check();
stdio_init_all();
setup_init();
config_init(pause_core1);
}
@ -140,9 +153,6 @@ void tud_hid_set_report_cb(uint8_t itf, uint8_t report_id,
{
if ((report_id == REPORT_ID_LIGHTS) &&
(report_type == HID_REPORT_TYPE_OUTPUT)) {
if (bufsize >= button_num()) {
button_set_hid_light(buffer, button_num());
}
if (bufsize >= rgb_button_num()) {
rgb_set_hid_light(buffer, rgb_button_num());
}

43
firmware/src/rgb.c
View File

@ -87,11 +87,12 @@ void rgb_set_level(uint8_t level)
uint8_t button_lights[BUTTON_RGB_NUM];
static uint32_t tt_led_buf[TT_RGB_NUM] = {0};
uint32_t *rgb_tt_buf = &tt_led_buf[TT_RGB_START];
uint32_t rgb_tt_size = TT_RGB_SIZE;
bool rgb_tt_reversed = TT_RGB_REVERSED;
uint32_t rgb_tt_angle = 0;
static uint32_t tt_led_buf[128] = {0};
uint32_t *tt_ring_buf = &tt_led_buf[0];
uint32_t tt_ring_start = 0;
uint32_t tt_ring_size = 24;
bool tt_ring_reversed = false;
uint32_t tt_ring_angle = 0;
static uint32_t button_led_buf[BUTTON_RGB_NUM] = {0};
@ -131,7 +132,7 @@ static void button_lights_update()
void rgb_set_angle(uint32_t angle)
{
rgb_tt_angle = angle;
tt_ring_angle = angle;
effects[current_effect].set_angle(angle);
}
@ -157,13 +158,31 @@ static void effect_update()
effects[current_effect].update(effects[current_effect].context);
}
#define FORCE_EXPIRE_DURATION 100000ULL
static uint64_t force_expire_time = 0;
void rgb_update()
{
effect_update();
button_lights_update();
if (time_us_64() > force_expire_time) {
effect_update();
button_lights_update();
}
drive_led();
}
void rgb_force_display(uint32_t *keyboard, uint32_t *tt)
{
for (int i = 0; i < BUTTON_RGB_NUM; i++) {
int led = button_rgb_map[i];
button_led_buf[led] = keyboard[i];
}
memset(tt_led_buf, 0, tt_ring_start * sizeof(uint32_t));
memcpy(tt_led_buf + tt_ring_start, tt, tt_ring_size * sizeof(uint32_t));
force_expire_time = time_us_64() + FORCE_EXPIRE_DURATION;
}
void rgb_init()
{
uint offset = pio_add_program(pio0, &ws2812_program);
@ -180,3 +199,11 @@ void rgb_reg_tt_effect(tt_effect_t effect)
effects[effect_num] = effect;
effect_num++;
}
void rgb_set_hardware(uint16_t tt_start, uint16_t tt_num, bool tt_reversed)
{
tt_ring_start = tt_start;
tt_ring_size = tt_num;
tt_ring_reversed = tt_reversed;
tt_ring_buf = &tt_led_buf[tt_start];
}

14
firmware/src/rgb.h
View File

@ -10,14 +10,19 @@
#include <stdbool.h>
void rgb_init();
void rgb_set_hardware(uint16_t tt_start, uint16_t tt_num, bool tt_reversed);
uint8_t rgb_button_num();
void rgb_update();
void rgb_set_angle(uint32_t angle);
void rgb_set_level(uint8_t level);
void rgb_set_button_light(uint16_t buttons);
void rgb_set_hid_light(uint8_t const *lights, uint8_t num);
void rgb_force_display(uint32_t *keyboard, uint32_t *tt);
typedef struct {
void (*init)(uint32_t context);
void (*set_level)(uint32_t level);
@ -28,10 +33,11 @@ typedef struct {
void rgb_reg_tt_effect(tt_effect_t effect);
extern uint32_t *rgb_tt_buf;
extern uint32_t rgb_tt_size;
extern uint32_t rgb_tt_angle;
extern bool rgb_tt_reversed;
/* These global variables meant to be accessed by effect codes */
extern uint32_t *tt_ring_buf;
extern uint32_t tt_ring_size;
extern uint32_t tt_ring_angle;
extern bool tt_ring_reversed;
uint32_t button_rgb32(uint32_t r, uint32_t g, uint32_t b, bool gamma_fix);
uint32_t tt_rgb32(uint32_t r, uint32_t g, uint32_t b, bool gamma_fix);

265
firmware/src/setup.c
View File

@ -6,3 +6,268 @@
*/
#include "setup.h"
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include "bsp/board.h"
#include "rgb.h"
#include "config.h"
iidx_cfg_t iidx_cfg;
static iidx_cfg_t cfg_save;
uint32_t setup_led_tt[128];
uint32_t setup_led_button[BUTTON_RGB_NUM];
static void cfg_loaded()
{
/* configuration validation */
}
void setup_init()
{
config_alloc(sizeof(iidx_cfg), &iidx_cfg, cfg_loaded);
}
typedef enum {
MODE_NONE,
MODE_TURNTABLE,
MODE_ANALOG,
MODE_TT_EFFECT,
MODE_KEY_COLOR,
} setup_mode_t;
static setup_mode_t current_mode = MODE_NONE;
static struct {
uint16_t last_keys;
uint16_t last_angle;
uint16_t keys;
int16_t angle;
uint16_t just_pressed;
uint16_t just_released;
int16_t rotate;
} input = { 0 };
#define KEY_1 0x0001
#define KEY_2 0x0002
#define KEY_3 0x0004
#define KEY_4 0x0008
#define KEY_5 0x0010
#define KEY_6 0x0020
#define KEY_7 0x0040
#define START 0x0080
#define EFFECT 0x0100
#define VEFX 0x0200
#define E4 0x0400
#define AUX_NO 0x0800
#define AUX_YES 0x1000
#define LED_KEY_1 0
#define LED_KEY_2 1
#define LED_KEY_3 2
#define LED_KEY_4 3
#define LED_KEY_5 4
#define LED_KEY_6 5
#define LED_KEY_7 6
#define LED_START 7
#define LED_EFFECT 8
#define LED_VEFX 9
#define LED_E4 10
#define PRESSED_ALL(k) ((input.keys & (k)) == (k))
#define PRESSED_ANY(k) (input.keys & (k))
#define JUST_PRESSED(k) (input.just_pressed & (k))
typedef void (*mode_func)();
static void join_mode(setup_mode_t new_mode);
static void quit_mode(bool apply);
static void nop()
{
}
static void check_exit()
{
if (JUST_PRESSED(AUX_YES)) {
quit_mode(true);
} else if (JUST_PRESSED(AUX_NO)) {
quit_mode(false);
}
}
static void mode_none_loop()
{
static bool escaped = false;
static uint64_t escape_time = 0;
if (PRESSED_ALL(AUX_YES | AUX_NO)) {
if (!escaped) {
escaped = true;
escape_time = time_us_64();
}
} else {
escaped = false;
}
if (!escaped) {
return;
}
uint16_t pressed = PRESSED_ANY(START | EFFECT | VEFX | E4);
if (pressed) {
escaped = false;
join_mode(MODE_ANALOG);
return;
}
if (time_us_64() - escape_time > 5000000) {
escaped = false;
join_mode(MODE_TURNTABLE);
}
}
static struct {
bool adjust_led_start;
uint16_t start_angle;
uint8_t counter;
} tt_ctx;
void mode_tt_enter()
{
tt_ctx.start_angle = input.angle;
}
void mode_tt_op()
{
if (JUST_PRESSED(START)) {
tt_ctx.adjust_led_start = true;
tt_ctx.start_angle = input.angle;
} else if (JUST_PRESSED(EFFECT)) {
tt_ctx.adjust_led_start = false;
tt_ctx.start_angle = input.angle;
} else if (JUST_PRESSED(VEFX)) {
iidx_cfg.tt_led.reversed = !iidx_cfg.tt_led.reversed;
tt_ctx.counter = iidx_cfg.tt_led.num;
} else if (JUST_PRESSED(E4)) {
iidx_cfg.tt_sensor_reversed = !iidx_cfg.tt_sensor_reversed;
tt_ctx.counter = iidx_cfg.tt_led.num;
}
int16_t delta = input.angle - tt_ctx.start_angle;
if (abs(delta) < 4) {
return;
}
tt_ctx.start_angle = input.angle;
if (tt_ctx.adjust_led_start) {
if ((delta > 0) && (iidx_cfg.tt_led.start < 8)) {
iidx_cfg.tt_led.start++;
} else if ((delta < -8) && (iidx_cfg.tt_led.start > 0)) {
iidx_cfg.tt_led.start--;
}
} else {
if ((delta < 0) && (iidx_cfg.tt_led.num < 128)) {
iidx_cfg.tt_led.num++;
} else if ((delta < -8) && (iidx_cfg.tt_led.num > 0)) {
iidx_cfg.tt_led.num--;
}
}
if (iidx_cfg.tt_led.start + iidx_cfg.tt_led.num > 128) {
iidx_cfg.tt_led.num = 128 - iidx_cfg.tt_led.start;
}
check_exit();
}
void mode_tt_loop()
{
for (int i = 0; i < iidx_cfg.tt_led.num; i++) {
int index = iidx_cfg.tt_led.start + i;
setup_led_tt[index] = tt_rgb32(10, 10, 10, false);
}
setup_led_tt[iidx_cfg.tt_led.start] = tt_rgb32(0xa0, 0, 0, false);
setup_led_tt[iidx_cfg.tt_led.start + iidx_cfg.tt_led.num -1 ] = tt_rgb32(0, 0xa0, 0, false);
if (tt_ctx.adjust_led_start) {
setup_led_button[LED_START] = tt_rgb32(0x80, 12, 12, false);
setup_led_button[LED_EFFECT] = 0;
} else {
setup_led_button[LED_START] = 0;
setup_led_button[LED_EFFECT] = tt_rgb32(12, 0x80, 12, false);
}
if (iidx_cfg.tt_led.reversed) {
setup_led_button[LED_VEFX] = tt_rgb32(0x80, 12, 12, false);
} else {
setup_led_button[LED_VEFX] = tt_rgb32(12, 0x80, 12, false);
}
if (iidx_cfg.tt_sensor_reversed) {
setup_led_button[LED_E4] = tt_rgb32(0x80, 12, 12, false);
} else {
setup_led_button[LED_E4] = tt_rgb32(12, 0x80, 12, false);
}
}
static struct {
mode_func operate;
mode_func loop;
mode_func enter;
} mode_defs[] = {
[MODE_NONE] = { nop, mode_none_loop, nop},
[MODE_TURNTABLE] = { mode_tt_op, mode_tt_loop, mode_tt_enter},
[MODE_ANALOG] = { check_exit, nop, nop},
[MODE_TT_EFFECT] = { check_exit, nop, nop},
[MODE_KEY_COLOR] = { check_exit, nop, nop},
};
static void join_mode(uint8_t new_mode)
{
cfg_save = iidx_cfg;
memset(&setup_led_tt, 0, sizeof(setup_led_tt));
memset(&setup_led_button, 0, sizeof(setup_led_button));
current_mode = new_mode;
mode_defs[current_mode].enter();
printf("Entering setup %d\n", new_mode);
}
static void quit_mode(bool apply)
{
if (apply) {
iidx_cfg = iidx_cfg;
config_request_save();
}
current_mode = MODE_NONE;
printf("Quit setup\n");
}
bool setup_run(uint16_t keys, uint16_t angle)
{
input.keys = keys;
input.angle = angle;
input.just_pressed = keys & ~input.last_keys;
input.just_released = ~keys & input.last_keys;
input.rotate = angle - input.last_angle;
if (input.just_pressed || input.just_released) {
printf("%4x %4x\n", input.just_pressed, input.just_released);
}
if (input.just_pressed || input.just_released || input.rotate) {
mode_defs[current_mode].operate();
}
mode_defs[current_mode].loop();
input.last_keys = keys;
input.last_angle = angle;
return current_mode != MODE_NONE;
}

19
firmware/src/setup.h
View File

@ -8,6 +8,7 @@
#include <stdint.h>
#include <stdbool.h>
#include "board_defs.h"
typedef struct __attribute ((packed)) {
uint8_t hue;
@ -19,8 +20,8 @@ typedef struct __attribute ((packed)) {
key_color_t key_off[11];
key_color_t key_on[11];
struct {
uint8_t led_start;
uint8_t led_num;
uint8_t start;
uint8_t num;
uint8_t effect;
uint8_t param;
uint8_t brightness;
@ -28,15 +29,19 @@ typedef struct __attribute ((packed)) {
} tt_led;
bool tt_sensor_reversed;
struct {
uint8_t vefx;
uint8_t play_vol;
uint8_t filter;
uint8_t eq_low;
uint8_t eq_hi;
uint8_t filter;
uint8_t play_vol;
} effects;
} iidx_cfg_t;
void report_moves(uint16_t key_flag, uint16_t tt_angle);
bool is_in_setup();
extern iidx_cfg_t iidx_cfg;
void setup_init();
bool setup_run(uint16_t key_flag, uint16_t tt_angle);
extern uint32_t setup_led_tt[];
extern uint32_t setup_led_button[BUTTON_RGB_NUM];
#endif

20
firmware/src/tt_blade.c
View File

@ -14,7 +14,7 @@
#include "hardware/timer.h"
#include "rgb.h"
static uint32_t blade_buf[256];
static uint32_t blade_buf[128];
static void blade_clear()
{
@ -42,17 +42,17 @@ static inline void blade_color_mix(int index, uint32_t color, uint32_t distance,
/* pos: 0..4095 */
static void blade_put_pixel(uint32_t pos, uint32_t color, uint32_t level)
{
pos = (pos % 4096) * rgb_tt_size / 16; // *256/4096, zoom in by 256x
pos = (pos % 4096) * tt_ring_size / 16; // *256/4096, zoom in by 256x
// calc brightness share between left and right LEDs
uint32_t index_left = pos >> 8;
uint32_t index_right = (index_left + 1) % rgb_tt_size;
uint32_t index_right = (index_left + 1) % tt_ring_size;
uint32_t dis_left = pos & 0xff;
uint32_t dis_right = 255 - dis_left;
if (rgb_tt_reversed) {
index_left = rgb_tt_size - 1 - index_left;
index_right = rgb_tt_size - 1 - index_right;
if (tt_ring_reversed) {
index_left = tt_ring_size - 1 - index_left;
index_right = tt_ring_size - 1 - index_right;
}
blade_color_mix(index_left, color, dis_left, level);
@ -112,9 +112,9 @@ static uint32_t apply_level(uint32_t color)
static void update(uint32_t context)
{
uint32_t delta = rgb_tt_angle > snake[0] ? rgb_tt_angle - snake[0] : snake[0] - rgb_tt_angle;
uint32_t delta = tt_ring_angle > snake[0] ? tt_ring_angle - snake[0] : snake[0] - tt_ring_angle;
snake[0] = rgb_tt_angle;
snake[0] = tt_ring_angle;
life[0] = 255;
life[1] = delta > 7 ? 255: delta * 8;
@ -136,8 +136,8 @@ static void update(uint32_t context)
life[i]--;
}
}
for (int i = 0; i < rgb_tt_size; i++) {
rgb_tt_buf[i] = apply_level(blade_buf[i]);
for (int i = 0; i < tt_ring_size; i++) {
tt_ring_buf[i] = apply_level(blade_buf[i]);
}
}

8
firmware/src/tt_rainbow.c
View File

@ -64,11 +64,11 @@ static void set_angle(uint32_t angle)
static void update(uint32_t context)
{
for (int i = 0; i < rgb_tt_size; i++) {
for (int i = 0; i < tt_ring_size; i++) {
uint32_t pitch = COLOR_WHEEL_SIZE * RGB_RING_CYCLE * i;
uint32_t index = (phase + pitch / rgb_tt_size) % COLOR_WHEEL_SIZE;
int led = rgb_tt_reversed ? rgb_tt_size - 1 - i: i;
rgb_tt_buf[led] = color_wheel[index];
uint32_t index = (phase + pitch / tt_ring_size) % COLOR_WHEEL_SIZE;
int led = tt_ring_reversed ? tt_ring_size - 1 - i: i;
tt_ring_buf[led] = color_wheel[index];
}
}

38
firmware/src/turntable.c
View File

@ -13,29 +13,14 @@
#include "hardware/gpio.h"
#include "hardware/i2c.h"
#include "config.h"
#include "board_defs.h"
#include "rgb.h"
static uint8_t as5600_addr = 0x36;
static uint16_t angle = 0;
static bool reversed = false;
typedef struct {
uint16_t ignore_this;
} tt_cfg_t;
static tt_cfg_t *cfg;
static void cfg_loaded()
{
}
static void init_cfg()
{
tt_cfg_t def = {0};
cfg = (tt_cfg_t *)config_alloc(sizeof(def), &def, cfg_loaded);
}
static void init_tt_i2c()
void turntable_init()
{
i2c_init(TT_AS5600_I2C, 800 * 1000);
gpio_set_function(TT_AS5600_SCL, GPIO_FUNC_I2C);
@ -44,14 +29,6 @@ static void init_tt_i2c()
gpio_pull_up(TT_AS5600_SDA);
}
void turntable_init()
{
init_cfg();
init_tt_i2c();
}
static uint16_t angle = 0;
void turntable_update()
{
uint8_t buf[2] = {0x0c, 0x00};
@ -60,10 +37,15 @@ void turntable_update()
i2c_read_blocking_until(TT_AS5600_I2C, as5600_addr, buf, 2, false,
time_us_64() + 1000);
angle = ((uint16_t)buf[0]) << 8 | buf[1];
angle = ((uint16_t)buf[0] & 0x0f) << 8 | buf[1];
}
void turntable_set_hardware(bool sensor_reversed)
{
reversed = sensor_reversed;
}
uint16_t turntable_read()
{
return angle; // 12bit
return reversed ? (4096 - angle) : angle; // 12bit
}

2
firmware/src/turntable.h
View File

@ -7,8 +7,10 @@
#define TURNTABLE_H
#include <stdint.h>
#include <stdbool.h>
void turntable_init();
void turntable_set_hardware(bool sensor_reversed);
uint16_t turntable_read();
void turntable_update();

5
firmware/src/usb_descriptors.c
View File

@ -142,10 +142,7 @@ char const* string_desc_arr[] = {
"E1",
"E2",
"E3",
"E4",
"Logo Red",
"Logo Green",
"Logo Blue"
"E4"
};
static uint16_t _desc_str[64];

10
firmware/src/usb_descriptors.h
View File

@ -29,12 +29,14 @@ enum {
HID_USAGE_MAX(11), \
HID_LOGICAL_MIN(0), HID_LOGICAL_MAX(1), HID_REPORT_COUNT(11), \
HID_REPORT_SIZE(1), HID_INPUT(HID_DATA | HID_VARIABLE | HID_ABSOLUTE), \
HID_REPORT_COUNT(1), HID_REPORT_SIZE(16 - 11), /*Padding*/\
HID_REPORT_COUNT(1), HID_REPORT_SIZE(16 - 11), /*Padding*/ \
HID_INPUT(HID_CONSTANT | HID_VARIABLE | HID_ABSOLUTE), \
HID_USAGE_PAGE(HID_USAGE_PAGE_DESKTOP), HID_LOGICAL_MIN(0x00), \
HID_LOGICAL_MAX_N(0x00ff, 2), \
HID_USAGE(HID_USAGE_DESKTOP_X), /*Joystick*/ \
HID_USAGE(HID_USAGE_DESKTOP_Y), HID_REPORT_COUNT(2), HID_REPORT_SIZE(8), \
HID_LOGICAL_MAX_N(0x00ff, 2), /* Below is Joystick/analog */ \
HID_USAGE(HID_USAGE_DESKTOP_X), HID_USAGE(HID_USAGE_DESKTOP_Y), \
HID_USAGE(HID_USAGE_DESKTOP_Z), HID_USAGE(HID_USAGE_DESKTOP_RX), \
HID_USAGE(HID_USAGE_DESKTOP_RY), HID_USAGE(HID_USAGE_DESKTOP_RZ), \
HID_REPORT_COUNT(6), HID_REPORT_SIZE(8), \
HID_INPUT(HID_DATA | HID_VARIABLE | HID_ABSOLUTE), HID_COLLECTION_END
// Light Map