Cleanup

added basic language support

.gitignore

@@ -1,5 +1,7 @@
+# Misc files
 /.vscode
+notes
 
 # Build files and final binary
 /build
-test
+hostdox

.gitmodules

@@ -0,0 +1,9 @@
+[submodule "libs/hidapi"]
+	path = libs/hidapi
+	url = ssh://git@git.betalupi.com:33/mirrors/hidapi.git
+[submodule "libs/spdlog"]
+	path = libs/spdlog
+	url = ssh://git@git.betalupi.com:33/mirrors/spdlog.git
+[submodule "libs/libmpdclient"]
+	path = libs/libmpdclient
+	url = ssh://git@git.betalupi.com:33/mirrors/libmpdclient.git

Makefile

@@ -1,10 +1,10 @@
-TARGET_EXEC := test
+TARGET_EXEC := hostdox
 BUILD_DIR := ./build
 SRC_DIRS := ./src
 
 # False targets
 # (these are the only ones you manually run)
-all: $(TARGET_EXEC)
+all: libs $(TARGET_EXEC)
 
 run: all
 	./$(TARGET_EXEC)
@@ -13,25 +13,73 @@ clean:
 	-rm -r $(BUILD_DIR)
 	@echo ""
 
-.PHONY: clean all run
+
+libs: $(BUILD_DIR)/hid.o $(BUILD_DIR)/libmpdclient.o
+
+submodules:
+	git submodule update --init --recursive
+
+.PHONY: clean all run libs submodules
 
 #################################################
 # Flags and autodetection
 
 # -MMD and -MP generate makefiles with extension .d.
-CPPFLAGS := -Wall -MMD -MP -I src
-LDFLAGS := -l fftw3
+CPPFLAGS := -MMD -MP \
+	-Wall \
+	-I src \
+	-I libs/hidapi/hidapi \
+	-I libs/spdlog/include \
+	-I libs/libmpdclient/include \
+	-I libs/libmpdclient/output \
+	$(shell pkg-config --cflags hunspell)
+
+# udev: required by hidapi
+LDFLAGS := \
+	-l fftw3 \
+	-l udev \
+	$(shell pkg-config --libs hunspell)
 
 # Find all cpp files in source dirs
 SRCS := $(shell find $(SRC_DIRS) -name '*.cpp')
-# Turns ./build/a.cpp into ./build/a.cpp.o
-OBJS := $(SRCS:%=$(BUILD_DIR)/%.o)
-# Turns ./build/a.cpp.o into ./build/a.cpp.d
+# Turns src/a.cpp into build/src/a.cpp.o
+SRC_OBJS := $(SRCS:%=$(BUILD_DIR)/%.o)
+LIB_OBJS := $(BUILD_DIR)/hid.o $(BUILD_DIR)/libmpdclient.o
+OBJS = $(SRC_OBJS) $(LIB_OBJS)
+# Turns build/a.cpp.o into build/a.cpp.d
 DEPS := $(OBJS:.o=.d)
 
 #################################################
 # Build targets
 
+
+### Libraries
+
+# Build hidapi
+$(BUILD_DIR)/hid.o:
+	@mkdir -p $(BUILD_DIR)
+
+	@echo "Compiling hid.o"
+	@gcc -Wall -g -fpic -c \
+		-I libs/hidapi/hidapi \
+		`pkg-config libusb-1.0 --cflags` \
+		libs/hidapi/linux/hid.c \
+		-o $(BUILD_DIR)/hid.o
+
+
+# Build libmpdclient
+$(BUILD_DIR)/libmpdclient.o:
+	@mkdir -p $(BUILD_DIR)
+
+	@cd libs/libmpdclient && \
+		meson . output && \
+		ninja -C output
+
+	ln -s ../libs/libmpdclient/output/libmpdclient.so $(BUILD_DIR)/libmpdclient.o
+
+
+### Source
+
 # C++ build step
 $(BUILD_DIR)/%.cpp.o: %.cpp
 	mkdir -p $(dir $@)
@@ -42,6 +90,5 @@ $(BUILD_DIR)/%.cpp.o: %.cpp
 $(TARGET_EXEC) : $(OBJS)
 	g++ $(OBJS) -o $@ $(LDFLAGS)
 
-
 # Include generated makefiles
 -include $(DEPS)

README.md

@@ -0,0 +1,34 @@
+# Ergodox Host Interface
+
+Host software for [Betalupi Ergodox](https://git.betalupi.com/Mark/QMK).
+
+## Features:
+ - Music visualizer ([here](https://git.betalupi.com/Mark/hostdox/src/branch/master/src/signal_processing))
+ - Spell checking with hunspell
+
+
+## Permissions
+
+You'll need to run this binary as a regular user. To allow access to raw hid, add the following udev rule and reboot:
+
+```conf
+KERNEL=="hidraw*", ATTRS{idVendor}=="3297", ATTRS{idProduct}=="4976", TAG+="uaccess", GROUP="mark", MODE="660"
+```
+
+See the hidraw repo for more information.
+
+
+## Dependencies:
+Run:
+ - hunspell
+
+Build:
+ - meson (for libmpdclient)
+ - ninja (for libmpdclient)
+ - gcc
+
+
+## Building
+
+``make submodules`` to initialize git submodules \
+``make all`` to build, or ``make run`` to build and run.

src/commands.h

@@ -0,0 +1,106 @@
+#pragma once
+
+
+
+
+// Sent by host when connection is initiated.
+//
+// Packet structure:
+// Data:		| cmd |
+// # of Bytes:	|  1  |
+#define CMD_HELLO 0x00
+
+
+
+
+// Sent periodically by host to test connection.
+// Keyboard should ignore this command.
+//
+// Packet structure:
+// Data:		| cmd |
+// # of Bytes:	|  1  |
+#define CMD_RUTHERE 0x01
+
+
+
+
+// Send keyboard state to host.
+//
+// Packet structure:
+// Data:		| cmd | anim state | layer state |  layer layout |
+// # of Bytes:	|  1  |     1      |      4      |       1       |
+//
+// anim state:
+// 0x00: RGBMatrix disabled
+// 0x01: normal animation, no HID data.
+// 0x02: FFT Animation
+//
+// layer state: layer state right now.
+// This is a uint32_t, where each bit corresponds to a layer index.
+// Lowest-order bit is base layer, highest bit is layer 31.
+// Layer indices are defined by the LAYER_* enum in layer.h,
+// host interface should have a matching enum.
+// Make sure to update it when you change your layers!
+//
+// layer layout:
+// The layout this layer was designed for.
+// 0x00: en_us
+// 0x01: russian
+#define CMD_SEND_STATE 0x02
+
+
+
+
+// Animation data. Sent by host.
+//
+// Packet structure:
+// Data:		| cmd | data type | data |
+// # of Bytes:	|  1  |     1     |  ?   |
+//
+// data type:
+// Which animation this data is for. These are defined below.
+//
+// data:
+// Animation data. Content depends on data type.
+#define CMD_ANIM_DATA 0x03
+
+// Data for FFT animation.
+// Data segment consists of 10 bits, each representing the height of a column.
+// Minimum height is 0, maximum is 250.
+#define CMD_ANIM_DATA_fft 0x00
+
+
+
+
+// Sent by keyboard to host when a complete word is typed.
+// Host checks if this is a known word.
+// If it is not, host responds with the same CMD (see below).
+//
+// Packet structure (sent by keyboard):
+// Data:		| cmd | word length |  keycodes  |
+// # of Bytes:	|  1  |      1      |     ?      |
+//
+// word length: number of bytes in `keycodes` block
+//
+//
+// Packet structure (sent by host):
+// Data:		| cmd | typo? |
+// # of Bytes:	|  1  |   1   |
+//
+// typo: If this is 0x01, the word we got was a typo.
+#define CMD_SPELLCHECK_WORD 0x04
+
+
+
+
+// Sent by host when a "special char" key is pressed.
+// Handled by host interface.
+//
+// Packet structure:
+// Data:		| cmd | character |
+// # of Bytes:	|  1  |     2     |
+//
+// character:
+// uint16_t, character id
+//
+#define CMD_SPECIAL_CHAR 0x05

src/config.h

@@ -0,0 +1,85 @@
+#pragma once
+
+
+/*
+	General Setup
+*/
+
+// USB device params
+#define HID_VENDOR_ID 0x3297
+#define HID_PRODUCT_ID 0x4976
+#define HID_USAGE 0x61
+#define HID_USAGE_PAGE 0xFF60
+
+// USB packet size, in bytes.
+// Usually 32, but depends on keyboard.
+#define RAW_EPSIZE 32
+
+// How many milliseconds to wait between reconnect attempts
+#define RECONNECT_SLEEP_MS 500
+
+// Keyboard layers.
+// These must have the same indices as
+// your layers in QMK.
+enum keyboard_layers {
+	LAYER_MAIN,
+	LAYER_RUSSIAN,
+	LAYER_SYMBOLS,
+	LAYER_SYMBOLS_RU,
+	LAYER_ARROWS,
+	LAYER_DESKTOP,
+	LAYER_FKEYS,
+	LAYER_KEYBOARD,
+	LAYER_NUMPAD
+};
+
+// Must match enum in keyboard
+enum layer_layout_ids {
+	LAYOUT_NULL,	// This layer doesn't care what keymap the OS is using
+	LAYOUT_EN,		// This layer is designed for the standard keymapping
+	LAYOUT_RU,
+};
+
+// Sleep this many millis after each loop.
+// Prevents absurd cpu usage.
+#define LOOP_SLEEP_MS 20
+
+
+
+
+
+/*
+	Autotype Special Characters
+*/
+//#define DISABLE_SPECIAL_CHAR
+
+
+
+/*
+	Spellcheck
+*/
+#define DISABLE_SPELL
+#ifndef DISABLE_SPELL
+	#define HUNSPELL_AFF_EN "/usr/share/hunspell/en_US.aff"
+	#define HUNSPELL_DIC_EN "/usr/share/hunspell/en_US.dic"
+#endif
+
+
+
+/*
+	Music Visualizer Animation
+*/
+#define DISABLE_VISUALIZER
+#ifndef DISABLE_VISUALIZER
+	// How many keys in a column * resolution per key.
+	// this MUST fit inside a uint8_t (i.e, <= 255).
+	#define KB_RESOLUTION (5 * 50)
+
+	// How many resolution steps to skip at the top and bottom.
+	#define BOTTOM_SKIP 100
+	#define TOP_SKIP 0
+
+	// Spectrum visualizer range
+	#define MIN_HZ 100
+	#define MAX_HZ 5000
+#endif

src/ergodox.cpp

@@ -0,0 +1,254 @@
+#include "ergodox.hpp"
+
+Ergodox::Ergodox(
+	unsigned short vendor_id,
+	unsigned short product_id,
+	unsigned short usage,
+	unsigned short usage_page
+) :
+	vendor_id(vendor_id),
+	product_id(product_id),
+	usage(usage),
+	usage_page(usage_page),
+	handle(NULL),
+	connected(false)
+{
+	hid_init();
+}
+
+
+
+/*
+Initialize Ergodox interface.
+
+Should be called once at start of execution. Arguments are the USB parameters of the keyboard.
+
+Returns instance of singleton.
+*/
+Ergodox& Ergodox::init(
+	unsigned short vendor_id,
+	unsigned short product_id,
+	unsigned short usage,
+	unsigned short usage_page
+) {
+	static bool has_been_initialized = false;
+	static Ergodox Instance(
+		vendor_id,
+		product_id,
+		usage,
+		usage_page
+	);
+
+	// This isn't strictly necessary, but there is no reason
+	// to call init() twice.
+	if (has_been_initialized) {
+		has_been_initialized = true;
+		throw std::runtime_error("Ergodox has already been initialized!");
+	}
+
+	return Instance;
+}
+
+
+// Instance is a static function variable,
+// and will be deleted at end of program.
+Ergodox::~Ergodox() {
+	disconnect();
+	hid_exit();
+}
+
+
+
+/*
+Try to open this keyboard's hid device.
+Throws a runtime error if device is already open.
+
+If we successfully open a device, this method sends a
+CMD_HELLO packet.
+
+@returns True if connection was successful, false otherwise.
+*/
+bool Ergodox::try_connect() {
+	if (connected) {
+		throw std::runtime_error("Device already open");
+	}
+
+	struct hid_device_info *devs, *cur_dev;
+	const char *path_to_open = NULL;
+
+	devs = hid_enumerate(vendor_id, product_id);
+	cur_dev = devs;
+	while (cur_dev) {
+		if (cur_dev->vendor_id == vendor_id &&
+			cur_dev->product_id == product_id &&
+			cur_dev->usage == usage &&
+			cur_dev->usage_page == usage_page
+		) {
+			path_to_open = cur_dev->path;
+			break;
+		}
+		cur_dev = cur_dev->next;
+	}
+
+	// Return false if connection failed
+	if (path_to_open) {
+		connected = true;
+
+		handle = hid_open_path(path_to_open);
+		hid_set_nonblocking(handle, 1);
+		hid_free_enumeration(devs);
+		write(CMD_HELLO, NULL, 0);
+
+		#define MAX_STR 255
+		wchar_t wstr[MAX_STR];
+		char nstr[MAX_STR];
+
+
+		spdlog::info("Connected to device!");
+
+		// Read metadata
+		wstr[0] = 0x0000;
+		hid_get_manufacturer_string(handle, wstr, MAX_STR);
+		misc::to_narrow(wstr, nstr, MAX_STR);
+		spdlog::info("Manufacturer String: {0}", nstr);
+
+		wstr[0] = 0x0000;
+		hid_get_product_string(handle, wstr, MAX_STR);
+		misc::to_narrow(wstr, nstr, MAX_STR);
+		spdlog::info("Product String: {0}", nstr);
+
+	} else {
+		connected = false;
+
+		hid_free_enumeration(devs);
+		return false;
+	}
+
+	return connected;
+}
+
+
+// Close hid device if it is open.
+void Ergodox::disconnect() {
+	connected = false;
+	if (handle != NULL) {
+		hid_close(handle);
+		handle = NULL;
+	}
+}
+
+
+/*
+Send data to Ergodox.
+
+@param cmd Command byte
+@param data Data to send
+@param data_len Data length. Must be shorter than packet_size.
+@returns True if successful, false otherwise.
+*/
+bool Ergodox::write(uint8_t cmd, const uint8_t* data, uint8_t data_len) {
+	if (!connected) {
+		throw std::runtime_error("Not connected, cannot write!");
+	} else if (handle == NULL) {
+		throw std::runtime_error("Tried to write a null handle, something is very wrong.");
+	} else if (data_len > packet_size) {
+		throw std::runtime_error("Data length exceeds packet size");
+	}
+
+	if (data == NULL) {
+		data = {0x00};
+	}
+
+	uint8_t packet[packet_size];
+	packet[0] = 0x00; // Report number. Not seen by keyboard.
+	packet[1] = cmd;  // First byte is always command
+
+	// Copy data into rest of packet
+	std::copy(data, data + data_len, packet + 2);
+
+	ssize_t res;
+	res = hid_write(handle, packet, packet_size + 1);
+
+	if (res < 0) {
+		spdlog::info("Lost device, disconnecting.");
+		disconnect();
+		return false;
+	}
+	return true;
+}
+
+
+/*
+Read data from Ergodox into read_buf. If a CMD_SEND_STATE packet is received, process it and return false.
+
+@returns True if a new command was received, false otherwise.
+*/
+bool Ergodox::read() {
+	if (!connected) {
+		throw std::runtime_error("Not connected, cannot read!");
+	} else if (handle == NULL) {
+		throw std::runtime_error("Tried to read a null handle, something is very wrong.");
+	}
+
+	ssize_t res;
+	res = hid_read(handle, read_buf, packet_size);
+
+	if (res == 0) {
+		return false;
+	} else if (res < 0) {
+		spdlog::info("Lost device, disconnecting.");
+		disconnect();
+		return false;
+	}
+
+	switch(read_buf[0]) {
+
+		// If keyboard sends a state packet, parse it.
+		case CMD_SEND_STATE:
+
+			// Byte 1: animation mode
+			if (animation_mode != read_buf[1]) {
+				spdlog::info("Mode set to 0x{0:02x}", read_buf[1]);
+				animation_mode = read_buf[1];
+			}
+
+			// Bytes 2,3,4,5: layer state
+			uint32_t new_layer_state =
+				(read_buf[5] << 24) |
+				(read_buf[4] << 16) |
+				(read_buf[3] << 8) |
+				(read_buf[2] << 0);
+
+			if (layer_state != new_layer_state) {
+				layer_state = new_layer_state;
+				spdlog::info("Layer set to 0b{0:032b}", layer_state);
+			}
+
+			// Byte 6: desired OS layout for layer
+			if (layer_layout != read_buf[6]) {
+				layer_layout = read_buf[6];
+				spdlog::info("Layout set to 0x{0:02x}", read_buf[6]);
+			}
+
+
+			// Main code should not parse state packets.
+			return false;
+	}
+
+	return true;
+}
+
+
+// Simple connectivity check
+void Ergodox::test_connection() {
+	write(CMD_RUTHERE, NULL, 0);
+}
+
+// Block until a connection is established.
+void Ergodox::connect_loop() {
+	spdlog::info("Trying to connect...");
+	while (!connected) {
+		try_connect();
+		std::this_thread::sleep_for(std::chrono::milliseconds(RECONNECT_SLEEP_MS));
+	}
+}

src/ergodox.hpp

@@ -0,0 +1,92 @@
+#pragma once
+
+#include <stdexcept>
+#include <cstdint>
+#include <wchar.h>
+// For sleep
+#include <chrono>
+#include <thread>
+
+#include "spdlog/spdlog.h"
+#include "hidapi.h"
+#include "utility/misc.h"
+#include "config.h"
+#include "commands.h"
+
+
+/*
+A singleton Ergodox interface. Wraps all hidapi methods, including
+hid_init() and hid_exit().
+*/
+class Ergodox {
+	public:
+
+		// USB Device parameters
+		const unsigned short vendor_id;
+		const unsigned short product_id;
+		const unsigned short usage;
+		const unsigned short usage_page;
+		const uint8_t packet_size = RAW_EPSIZE;
+
+		static Ergodox& init(
+			unsigned short vendor_id,
+			unsigned short product_id,
+			unsigned short usage,
+			unsigned short usage_page
+		);
+
+		~Ergodox();
+
+		bool try_connect();
+		void disconnect();
+		void test_connection();
+		void connect_loop();
+
+		bool read();
+		bool write(uint8_t cmd, const uint8_t* data, uint8_t data_len);
+
+
+		// Read buffer, len = packet_size.
+		// Filled by read().
+		uint8_t read_buf[RAW_EPSIZE];
+
+
+		// Getter methods
+		uint8_t get_animation_mode() const { return animation_mode; }
+		bool is_connected() const { return connected; }
+		uint32_t get_layer_state() const {return layer_state; }
+		uint8_t get_layer_layout() const { return layer_layout; }
+		bool is_layer_on(uint8_t layer) const { return (layer_state >> layer) % 2; }
+
+	private:
+		Ergodox(
+			unsigned short vendor_id,
+			unsigned short product_id,
+			unsigned short usage,
+			unsigned short usage_page
+		);
+
+		// Disable copy and assignment
+		//Ergodox(void);
+		//Ergodox(Ergodox& other);
+		//Ergodox& operator=(Ergodox& other);
+
+		// HID device.
+		// NULL if not opened.
+		hid_device* handle;
+
+		// Keyboard state variables.
+		// Updated by read().
+
+		// Which animation is the keyboard running right now?
+		// See CMD_SEND_STATE in commands.h for docs.
+		uint8_t animation_mode;
+		// Active layer bitmask.
+		// See CMD_SEND_STATE in commands.h for docs.
+		uint32_t layer_state;
+		// Desired layout for active layer.
+		// See CMD_SEND_STATE in commands.h for docs.
+		uint8_t layer_layout;
+		// Are we connected to a keyboard right now?
+		bool connected;
+};

src/main.cpp

@@ -0,0 +1,151 @@
+#include <stdio.h>
+#include <cstdint>
+#include <vector>
+#include <stdexcept>
+#include <string>
+
+// For reading FIFO
+#include <fcntl.h>
+#include <unistd.h>
+
+// For sleep
+#include <thread>
+
+// Local files
+#include "ergodox.hpp"
+#include "commands.h"
+#include "config.h"
+
+
+#include "spdlog/spdlog.h"
+
+#ifndef DISABLE_SPECIAL_CHAR
+#include "modules/special_chars.hpp"
+#endif
+
+#ifndef DISABLE_SPELL
+#include "modules/spell.hpp"
+#endif
+
+#ifndef DISABLE_VISUALIZER
+#include "modules/visualizer.hpp"
+#endif
+
+// TODO:
+//
+// MPD connection error handling
+// Cleaner building
+//
+// FFT:
+//   stereo support (and maybe different bitrates?)
+//   Optimization: don't copy filename in buffer?
+//   understand consumption rate
+//   understand BIN2HZ
+//   understand values and sizes (DFT_TOTAL, DFT_NONZERO, etc)
+//     note that wave and spectrum have different sizes
+//   clear fft when not in use
+//
+//
+// Keyboard interface:
+//   Fix segfault
+//   Clean up reconnect code
+//   Better log messages, compiled spdlog
+//
+//   Get parameters from keyboard (width, height, etc)
+//
+// Later:
+//   beat detection
+//   waveform animation
+//   pcm from pulse
+
+
+// HID interface wrapper
+Ergodox Dox = Ergodox::init(
+	HID_VENDOR_ID,
+	HID_PRODUCT_ID,
+	HID_USAGE,
+	HID_USAGE_PAGE
+);
+
+
+int main(int argc, char *argv[]) {
+	spdlog::set_level(spdlog::level::info);
+
+
+	uint8_t last_layer_layout;
+
+	Dox.connect_loop();
+
+	#ifndef DISABLE_VISUALIZER
+	Visualizer::init();
+	#endif
+
+	while (1) {
+
+		if (Dox.is_connected()) {
+			#ifndef DISABLE_VISUALIZER
+			Visualizer::fn(Dox);
+			#endif
+
+			// Dox.write might detect that we've been disconnected,
+			// and Dox.read will fail if we are.
+			// This check prevents it from doing that, and instead jumps to reconnect.
+			if (!Dox.is_connected()) { continue; }
+
+			// Read a packet if there is a packet to read
+			if (Dox.read()) {
+				uint8_t cmd = Dox.read_buf[0];
+
+				switch (cmd) {
+
+					#ifndef DISABLE_SPELL
+					case CMD_SPELLCHECK_WORD: {
+						Spell::do_cmd(Dox);
+						break;
+					}
+					#endif
+
+					#ifndef DISABLE_SPECIAL_CHAR
+					case CMD_SPECIAL_CHAR: {
+						SpecialChars::do_cmd(Dox);
+						break;
+					}
+					#endif
+				}
+			}
+
+
+			// Switch layer if necessary.
+			if (
+				(last_layer_layout != Dox.get_layer_layout()) &&
+				(Dox.get_layer_layout() != LAYOUT_NULL)
+			) {
+
+				last_layer_layout = Dox.get_layer_layout();
+
+				switch(last_layer_layout) {
+					case (LAYOUT_EN):
+						std::system("awesome-client \"modules.ibus.set('en')\"");
+						break;
+					case (LAYOUT_RU):
+						std::system("awesome-client \"modules.ibus.set('ru')\"");
+						break;
+				}
+			}
+
+		} else {
+			Dox.connect_loop();
+		}
+
+		// Sleep for a bit so we don't consume
+		// 100% of a cpu.
+		std::this_thread::sleep_for(
+			std::chrono::milliseconds(LOOP_SLEEP_MS)
+		);
+	}
+
+	#ifndef DISABLE_VISUALIZER
+	Visualizer::cleanup();
+	#endif
+	return 0;
+}

src/modules/special_chars.cpp

@@ -0,0 +1,25 @@
+#include "special_chars.hpp"
+#ifndef DISABLE_SPECIAL_CHAR
+
+
+namespace SpecialChars {
+	void do_cmd(Ergodox &Dox) {
+		// Bytes 1,2: char id
+		uint16_t char_id =
+			(Dox.read_buf[2] << 8) |
+			(Dox.read_buf[1] << 0);
+
+		spdlog::info("{0:d}", char_id);
+
+		if (char_id < (sizeof(special_chars) / sizeof(std::string))) {
+			std::system(
+				(
+					std::string("xdotool type \"") +
+					special_chars[char_id] +
+					std::string("\"")
+				).c_str()
+			);
+		}
+	}
+}
+#endif

src/modules/special_chars.hpp

@@ -0,0 +1,28 @@
+#pragma once
+#include "config.h"
+#ifndef DISABLE_SPECIAL_CHAR
+
+#include <string>
+#include "ergodox.hpp"
+
+namespace SpecialChars {
+	const std::string special_chars[] = {
+
+		// These characters are used to type
+		// symbols on layouts that don't have
+		// them.
+		"\\`",
+		"~",
+		"'",
+		"[",
+		"]",
+		"{",
+		"}",
+		"«",
+		"»"
+	};
+
+	void do_cmd(Ergodox &Dox);
+}
+
+#endif

src/modules/spell.cpp

@@ -0,0 +1,133 @@
+#include "spell.hpp"
+#ifndef DISABLE_SPELL
+
+namespace Spell {
+	Hunspell* hun = new Hunspell(HUNSPELL_AFF_EN, HUNSPELL_DIC_EN);
+	uint8_t hid_buf[RAW_EPSIZE]; // Write buffer
+	
+
+	// Replacement chars for now, since wide strings are hard.
+	char ru_kc_to_char(uint8_t keycode) {
+		switch (keycode) {
+			case KC_GRAVE:
+				return '~';//L"ё";
+			case KC_1:
+				return '1';//L"1";
+			case KC_2:
+				return '2';//L"2";
+			case KC_3:
+				return '3';//L"3";
+			case KC_4:
+				return '4';//L"4";
+			case KC_5:
+				return '5';//L"5";
+			case KC_6:
+				return '6';//L"6";
+			case KC_7:
+				return '7';//L"7";
+			case KC_8:
+				return '8';//L"8";
+			case KC_9:
+				return '9';//L"9";
+			case KC_0:
+				return '0';//L"0";
+			case KC_Q:
+				return '^';//L"й";
+			case KC_W:
+				return '*';//L"ц";
+			case KC_E:
+				return 'y';//L"у";
+			case KC_R:
+				return 'k';//L"к";
+			case KC_T:
+				return 'e';//L"е";
+			case KC_Y:
+				return 'H';//L"н";
+			case KC_U:
+				return 'g';//L"г";
+			case KC_I:
+				return 'w';//L"ш";
+			case KC_O:
+				return 'W';//L"щ";
+			case KC_P:
+				return 'z';//L"з";
+			case KC_LEFT_BRACKET:
+				return 'x';//L"х";
+			case KC_RIGHT_BRACKET:
+				return '!';//L"ъ";
+			case KC_A:
+				return 'f';//L"ф";
+			case KC_S:
+				return 'i';//L"ы";
+			case KC_D:
+				return 'B';//L"в";
+			case KC_F:
+				return 'a';//L"а";
+			case KC_G:
+				return 'n';//L"п";
+			case KC_H:
+				return 'p';//L"р";
+			case KC_J:
+				return 'o';//L"о";
+			case KC_K:
+				return 'l';//L"л";
+			case KC_L:
+				return 'd';//L"д";
+			case KC_SEMICOLON:
+				return 'j';//L"ж";
+			case KC_QUOTE:
+				return 'E';//L"э";
+			case KC_Z:
+				return 'R';//L"я";
+			case KC_X:
+				return 'q';//L"ч";
+			case KC_C:
+				return 'c';//L"с";
+			case KC_V:
+				return 'm';//L"м";
+			case KC_B:
+				return 'n';//L"и";
+			case KC_N:
+				return 't';//L"т";
+			case KC_M:
+				return '=';//L"ь";
+			case KC_COMMA:
+				return 'b';//L"б";
+			case KC_DOT:
+				return 'u';//L"ю";
+			default:
+				spdlog::warn("Unknown keycode passed to ru_kc_to_char");
+				return '?';//L"?";
+		}
+	}
+
+
+	void do_cmd(Ergodox &Dox) {
+		char word_chars[Dox.read_buf[1] + 1];
+
+		if (Dox.get_layer_layout() == LAYOUT_EN) {
+			for (int i=0; i < Dox.read_buf[1]; i++) {
+				// A in ascii:
+				// a in ascii: 0x61
+				// KC_A: 0x04
+				word_chars[i] = Dox.read_buf[i + 2] + 0x5D;
+			}
+		} else if (Dox.get_layer_layout() == LAYOUT_RU) {
+			for (int i=0; i < Dox.read_buf[1]; i++) {
+				word_chars[i] = ru_kc_to_char(Dox.read_buf[i + 2]);
+			}
+		}
+		word_chars[Dox.read_buf[1]] = 0x00; // Terminate with null char
+		std::string word = std::string(word_chars);
+
+		int dp = hun->spell(word);
+		if (!dp) {
+			memset(hid_buf, 0, sizeof(uint8_t) * Dox.packet_size);
+			hid_buf[0] = 0x01;
+			Dox.write(CMD_SPELLCHECK_WORD, hid_buf, Dox.packet_size);
+			//spdlog::info("Got typo: \"{0:s}\" not in dict", word);
+		}
+	}
+}
+
+#endif

src/modules/spell.hpp

@@ -0,0 +1,181 @@
+#pragma once
+#include "config.h"
+#ifndef DISABLE_SPELL
+
+#include "hunspell.hxx"
+#include "ergodox.hpp"
+
+namespace Spell {
+	char ru_kc_to_char(uint8_t keycode);
+	void do_cmd(Ergodox &Dox);
+}
+
+enum hid_keyboard_keypad_usage {
+	KC_NO = 0x00,
+	KC_ROLL_OVER,
+	KC_POST_FAIL,
+	KC_UNDEFINED,
+	KC_A,
+	KC_B,
+	KC_C,
+	KC_D,
+	KC_E,
+	KC_F,
+	KC_G,
+	KC_H,
+	KC_I,
+	KC_J,
+	KC_K,
+	KC_L,
+	KC_M, // 0x10
+	KC_N,
+	KC_O,
+	KC_P,
+	KC_Q,
+	KC_R,
+	KC_S,
+	KC_T,
+	KC_U,
+	KC_V,
+	KC_W,
+	KC_X,
+	KC_Y,
+	KC_Z,
+	KC_1,
+	KC_2,
+	KC_3, // 0x20
+	KC_4,
+	KC_5,
+	KC_6,
+	KC_7,
+	KC_8,
+	KC_9,
+	KC_0,
+	KC_ENTER,
+	KC_ESCAPE,
+	KC_BACKSPACE,
+	KC_TAB,
+	KC_SPACE,
+	KC_MINUS,
+	KC_EQUAL,
+	KC_LEFT_BRACKET,
+	KC_RIGHT_BRACKET, // 0x30
+	KC_BACKSLASH,
+	KC_NONUS_HASH,
+	KC_SEMICOLON,
+	KC_QUOTE,
+	KC_GRAVE,
+	KC_COMMA,
+	KC_DOT,
+	KC_SLASH,
+	KC_CAPS_LOCK,
+	KC_F1,
+	KC_F2,
+	KC_F3,
+	KC_F4,
+	KC_F5,
+	KC_F6,
+	KC_F7, // 0x40
+	KC_F8,
+	KC_F9,
+	KC_F10,
+	KC_F11,
+	KC_F12,
+	KC_PRINT_SCREEN,
+	KC_SCROLL_LOCK,
+	KC_PAUSE,
+	KC_INSERT,
+	KC_HOME,
+	KC_PAGE_UP,
+	KC_DELETE,
+	KC_END,
+	KC_PAGE_DOWN,
+	KC_RIGHT,
+	KC_LEFT, // 0x50
+	KC_DOWN,
+	KC_UP,
+	KC_NUM_LOCK,
+	KC_KP_SLASH,
+	KC_KP_ASTERISK,
+	KC_KP_MINUS,
+	KC_KP_PLUS,
+	KC_KP_ENTER,
+	KC_KP_1,
+	KC_KP_2,
+	KC_KP_3,
+	KC_KP_4,
+	KC_KP_5,
+	KC_KP_6,
+	KC_KP_7,
+	KC_KP_8, // 0x60
+	KC_KP_9,
+	KC_KP_0,
+	KC_KP_DOT,
+	KC_NONUS_BACKSLASH,
+	KC_APPLICATION,
+	KC_KB_POWER,
+	KC_KP_EQUAL,
+	KC_F13,
+	KC_F14,
+	KC_F15,
+	KC_F16,
+	KC_F17,
+	KC_F18,
+	KC_F19,
+	KC_F20,
+	KC_F21, // 0x70
+	KC_F22,
+	KC_F23,
+	KC_F24,
+	KC_EXECUTE,
+	KC_HELP,
+	KC_MENU,
+	KC_SELECT,
+	KC_STOP,
+	KC_AGAIN,
+	KC_UNDO,
+	KC_CUT,
+	KC_COPY,
+	KC_PASTE,
+	KC_FIND,
+	KC_KB_MUTE,
+	KC_KB_VOLUME_UP, // 0x80
+	KC_KB_VOLUME_DOWN,
+	KC_LOCKING_CAPS_LOCK,
+	KC_LOCKING_NUM_LOCK,
+	KC_LOCKING_SCROLL_LOCK,
+	KC_KP_COMMA,
+	KC_KP_EQUAL_AS400,
+	KC_INTERNATIONAL_1,
+	KC_INTERNATIONAL_2,
+	KC_INTERNATIONAL_3,
+	KC_INTERNATIONAL_4,
+	KC_INTERNATIONAL_5,
+	KC_INTERNATIONAL_6,
+	KC_INTERNATIONAL_7,
+	KC_INTERNATIONAL_8,
+	KC_INTERNATIONAL_9,
+	KC_LANGUAGE_1, // 0x90
+	KC_LANGUAGE_2,
+	KC_LANGUAGE_3,
+	KC_LANGUAGE_4,
+	KC_LANGUAGE_5,
+	KC_LANGUAGE_6,
+	KC_LANGUAGE_7,
+	KC_LANGUAGE_8,
+	KC_LANGUAGE_9,
+	KC_ALTERNATE_ERASE,
+	KC_SYSTEM_REQUEST,
+	KC_CANCEL,
+	KC_CLEAR,
+	KC_PRIOR,
+	KC_RETURN,
+	KC_SEPARATOR,
+	KC_OUT, // 0xA0
+	KC_OPER,
+	KC_CLEAR_AGAIN,
+	KC_CRSEL,
+	KC_EXSEL,
+};
+
+#endif

src/modules/visualizer.cpp

@@ -0,0 +1,80 @@
+#include "visualizer.hpp"
+#ifndef DISABLE_VISUALIZER
+
+namespace Visualizer {
+	uint8_t hid_buf[RAW_EPSIZE]; // Write buffer
+	struct mpd_connection *conn;
+
+	FFT_Visualizer fft = FFT_Visualizer(
+		width, height, MIN_HZ, MAX_HZ
+	);
+
+	std::chrono::time_point<
+		std::chrono::steady_clock,
+		std::chrono::nanoseconds
+	> t;
+
+	std::chrono::time_point<
+		std::chrono::steady_clock,
+		std::chrono::nanoseconds
+	> last_fifo_sync;
+
+	// buffer size for waveform:
+	// (44100 / fps * 10), make 10 bigger for slower scrolling
+	//
+	// Double both buffer sizes if stereo
+		Buffer buf = Buffer(
+		"/tmp/mpd.fifo",
+		44100 / 2, // Keep 500ms of data in buffer
+		fft.compute_buffer_output_size()
+	);
+
+	void init() {
+		// Frame rate limiter
+		t = std::chrono::steady_clock::now();
+		last_fifo_sync = std::chrono::steady_clock::now();
+		conn = mpd_connection_new(NULL, 0, 0);
+	}
+
+	void cleanup() {
+		mpd_connection_free(Visualizer::conn);
+	}
+
+	void fn(Ergodox &Dox) {
+		if (std::chrono::steady_clock::now() > t + std::chrono::milliseconds(30)) {
+			if (Dox.get_animation_mode() == 0x02) {
+
+				// Animation data type
+				hid_buf[1] = CMD_ANIM_DATA_fft;
+
+				if (std::chrono::steady_clock::now() > last_fifo_sync + std::chrono::seconds(10)) {
+					mpd_run_disable_output(conn, 1);
+					mpd_run_enable_output(conn, 1);
+					last_fifo_sync = std::chrono::steady_clock::now();
+					spdlog::info("Synchronized fifo");
+				}
+
+				buf.update();
+				fft.update(buf);
+
+				for (size_t i = 0; i < 10; i++) {
+					// Get height from fft, apply bottom_skip
+					ssize_t h = fft.get_output()[i] - BOTTOM_SKIP;
+
+					// Enforce max and min
+					// max implicitly enforces top_skip
+					h = h>KB_RESOLUTION ? KB_RESOLUTION : h;
+					h = h<0 ? 0 : h;
+
+					hid_buf[i + 1] = h;
+				}
+				Dox.write(CMD_ANIM_DATA, hid_buf, Dox.packet_size);
+			}
+
+
+			t = std::chrono::steady_clock::now();
+		}
+	}
+}
+
+#endif

src/modules/visualizer.hpp

@@ -0,0 +1,23 @@
+#pragma once
+#include "config.h"
+#ifndef DISABLE_VISUALIZER
+
+#include "utility/buffer.hpp"
+#include <chrono>
+#include "mpd/client.h"
+#include "signal_processing/fft.hpp"
+#include "spdlog/spdlog.h"
+#include "ergodox.hpp"
+#include "commands.h"
+
+namespace Visualizer {
+
+	const size_t width = 10;
+	const size_t height = BOTTOM_SKIP + KB_RESOLUTION + TOP_SKIP;
+
+	void cleanup();
+	void init();
+	void fn(Ergodox &Dox);
+}
+
+#endif

src/signal_processing/fft.hpp

@@ -43,9 +43,9 @@ class FFT_Visualizer {
 		// Visualizer parameters
 		///
 
-		// How many bars this visualizer will generate
+		// Horizontal resolution
 		const size_t width;
-		// Resolution of this visualizer's bars.
+		// Vertical resolution
 		const size_t height;
 		// Leftmost frequency in spectrum
 		const double HZ_MIN;

src/test.cpp

@@ -1,78 +0,0 @@
-#include <stdio.h>
-#include <cstdint>
-#include <vector>
-
-// For reading FIFO
-#include <fcntl.h>
-#include <unistd.h>
-// Math libs
-#include <math.h>
-#include <fftw3.h>
-
-// Local files
-#include "utility/bitmap.hpp"
-#include "utility/buffer.hpp"
-#include "signal_processing/fft.hpp"
-
-
-// TODO:
-// stereo support (and maybe different bitrates?)
-// Optimization: don't copy filename in buffer?
-// understand consumption rate
-// understand BIN2HZ
-// understand values and sizes (DFT_TOTAL, DFT_NONZERO, etc)
-//   note that wave and spectrum have different sizes
-//
-// MPD interface
-// hid interface to keyboard
-// beat detection
-
-
-
-
-void draw_spectrum_bitmap(
-	const std::vector<size_t>& waveform,
-	Bitmap& bitmap
-) {
-	for (size_t x = 0; x < waveform.size(); x++) {
-		for (size_t y = 0; y < waveform[x]; y++) {
-			bitmap.setpixel(bitmap.get_height() - y - 1, x, 0xFF, 0x00, 0x00);
-		}
-	}
-}
-
-const size_t width = 300;
-const size_t height = 100;
-
-
-int main(int argc, char *argv[]) {
-
-	// buffer size for waveform:
-	// (44100 / fps * 10), make 10 bigger for slower scrolling
-	//
-	// Double both buffer sizes if stereo
-
-	FFT_Visualizer fft = FFT_Visualizer(
-		width, height,
-		20, 20000
-	);
-
-	std::vector<size_t> waveform;
-	waveform.resize(width);
-
-	Buffer buf = Buffer(
-		"/tmp/mpd.fifo",
-		44100 / 2, // Keep 500ms of data in buffer
-		fft.compute_buffer_output_size()
-	);
-
-	Bitmap b = Bitmap(width, height);
-
-	while (1) {
-		b.clear();
-		buf.update();
-		fft.update(buf);
-		draw_spectrum_bitmap(fft.get_output(), b);
-		b.save("/tmp/o.bmp");
-	}
-}

src/utility/bitmap.cpp

@@ -1,5 +1,9 @@
 #include "bitmap.hpp"
 
+
+// Simple bitmap library.
+// Used to debug music visualizer.
+
 Bitmap::Bitmap(size_t w, size_t h) {
 	this->width = w;
 	this->height = h;

src/utility/misc.cpp

@@ -0,0 +1,28 @@
+#include "misc.h"
+
+
+namespace misc {
+	size_t to_narrow(const wchar_t * src, char * dest, size_t dest_len) {
+		size_t i;
+		wchar_t code;
+
+		i = 0;
+
+		while (src[i] != '\0' && i < (dest_len - 1)) {
+			code = src[i];
+			if (code < 128) {
+				dest[i] = char(code);
+			} else {
+				dest[i] = '?';
+				if (code >= 0xD800 && code <= 0xD8FF) {
+					i++;
+				}
+			}
+			i++;
+		}
+
+		dest[i] = '\0';
+		return i - 1;
+	}
+
+}

src/utility/misc.h

@@ -0,0 +1,6 @@
+#pragma once
+#include <stdio.h>
+
+namespace misc {
+	size_t to_narrow(const wchar_t * src, char * dest, size_t dest_len);
+}