sxkbd

main.c (4133B)

#include "board.h"
#include "usb_stdio.h"
#include "keymat.h"
#include "keysym.h"
#include "split.h"
#include "led.h"
#include "hid.h"
#include "keymap.h"
#include "ws2812.h"
#include "util.h"

#include "hardware/gpio.h"
#include "class/cdc/cdc_device.h"
#include "class/hid/hid.h"
#include "device/usbd.h"
#include "pico/stdlib.h"
#include "bsp/board.h"
#include "pico/time.h"
#include "tusb.h"

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

void cdc_task(void);

static void
unassigned_init(void)
{
#ifdef BAD_GPIO_MITIGATION
#pragma message("Enabled bad gpio mitigation to swap gpio pins 5 & 9")
	const uint unassigned[] = { 8, 5, 23, 21 };
#else
	const uint unassigned[] = { 8, 9, 23, 21 };
#endif
	uint i;

	for (i = 0; i < ARRLEN(unassigned); i++) {
		gpio_init(unassigned[i]);
		gpio_set_dir(unassigned[i], GPIO_IN);
	}
}

int
main(void)
{
	uint32_t start, stop;

	board_init();
	tud_init(BOARD_TUD_RHPORT);
	usb_stdio_init();
	led_init();
	keymat_init();
	split_init();
	hid_init();
	unassigned_init();

	led_start_blip(HARD_WHITE, 500);

	start = board_millis();
	while (true) {
		tud_task();
		led_task();
		split_task();
		if (split_role == MASTER) {
			cdc_task();
			hid_task();
		}

		stop = board_millis();
		DEBUG(LOG_TIMING, "Main loop: %i ms", stop - start);
		start = stop;
	}

	return 0;
}

void
tud_mount_cb(void)
{
#ifndef SPLIT_ROLE
	split_role = MASTER;
#endif
	led_rgb = SOFT_PURPLE;
	led_mode = LED_ON;
	led_reset = true;
}

void
tud_umount_cb(void)
{
	led_blink_ms = 500;
	led_rgb = SOFT_WHITE;
	led_mode = LED_BLINK;
	led_reset = true;

	led_start_blip(HARD_WHITE, 500);
}

void
tud_suspend_cb(bool remote_wakeup_en)
{
#ifndef SPLIT_ROLE
	split_role = SLAVE;
#endif
	led_rgb = SOFT_WHITE;
	led_mode = LED_ON;
	led_reset = true;
}

void
tud_resume_cb(void)
{
	led_rgb = SOFT_PURPLE;
	led_mode = LED_ON;
	led_reset = true;
}

void
tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts)
{
}

void
tud_cdc_rx_cb(uint8_t itf)
{
}

uint16_t
tud_hid_get_report_cb(uint8_t itf, uint8_t report_id,
	hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen)
{
	return 0;
}

void
tud_hid_set_report_cb(uint8_t itf, uint8_t report_id,
	hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize)
{
}

void
process_cmd(char *cmd)
{
	char *arg, *tok;

	tok = strchr(cmd, ' ');
	if (tok) {
		*tok = '\0';
		arg = tok + 1;
	} else {
		arg = cmd + strlen(cmd);
	}

	if (!strcmp(cmd, "log-level")) {
		if (!strcmp(arg, "")) {
			printf("Levels: debug, info, warn, err\n");
		} else if (!strcmp(arg, "debug")) {
			log_level_min = LOG_DEBUG;
		} else if (!strcmp(arg, "info")) {
			log_level_min = LOG_INFO;
		} else if (!strcmp(arg, "warn")) {
			log_level_min = LOG_WARN;
		} else {
			printf("Invalid log level: %s\n", arg);
		}
	} else if (!strcmp(cmd, "log-groups")) {
		log_group_mask = 0;
		while (1) {
			tok = strchr(arg, ',');
			if (tok) *tok = '\0';
			if (!strcmp(arg, "all")) {
				log_group_mask |= LOG_ALL;
			} else if (!strcmp(arg, "keymat")) {
				log_group_mask |= LOG_KEYMAT;
			} else if (!strcmp(arg, "timing")) {
				log_group_mask |= LOG_TIMING;
			} else if (strspn(arg, "\t ") == strlen(arg)) {
				/* ignore */
			} else {
				printf("Invalid log facility: %s\n", arg);
			}
			if (!tok) break;
			arg = tok + 1;
		}
	} else if (!strcmp(cmd, "warn")) {
		if (*warnlog) {
			printf("Warning: %s\n", warnlog);
			*warnlog = '\0';
		} else {
			printf("No warnings logged\n");
		}
	} else {
		printf("Invalid command: %s\n", cmd);
	}
}

void
cdc_task(void)
{
	static char cmdbuf[256];
	static int cmdlen = 0;
	char c;

	do {
		if (cmdlen)
			tud_task();

		if (tud_cdc_connected() && tud_cdc_available()
				&& tud_cdc_read(&c, 1)) {
			if (c == '\r' || c == '\n') {
				printf("\n");
				tud_cdc_write_flush();
				if (cmdlen) {
					cmdbuf[cmdlen] = 0;
					process_cmd(cmdbuf);
					cmdlen = 0;
				}
			} else if (c == 4) {
				printf("ALIVE!\n");
			} else if (cmdlen == ARRLEN(cmdbuf)) {
				printf("\n--- cmd too long ---\n");
				cmdlen = 0;
			} else {
				printf("%c", c);
				tud_cdc_write_flush();
				cmdbuf[cmdlen++] = c;
			}
		}
	} while (cmdlen);
}