Replaced simple dict file with hunspell,

added basic language support

Makefile

@@ -31,7 +31,8 @@ CPPFLAGS := -MMD -MP \
 	-I libs/libmpdclient/output
 
 # udev: required by hidapi
-LDFLAGS := -l fftw3 -l udev
+# TODO: better hunspell link
+LDFLAGS := -l fftw3 -l udev -l hunspell-1.7
 
 # Find all cpp files in source dirs
 SRCS := $(shell find $(SRC_DIRS) -name '*.cpp')

src/commands.h

@@ -18,13 +18,25 @@
 // Send keyboard state to host.
 //
 // Packet structure:
-// Data:		| cmd | anim state |
-// # of Bytes:	|  1  |     1      |
+// 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
 
 // Sent by keyboard to host when a complete word is typed.

src/config.h

@@ -1,10 +1,33 @@
 #pragma once
 
+// 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
 
+#define HUNSPELL_AFF_EN "/usr/share/hunspell/en_US.aff"
+#define HUNSPELL_DIC_EN "/usr/share/hunspell/en_US.dic"
 
 // USB device params
 #define HID_VENDOR_ID 0x3297

src/dict.cpp

@@ -1,16 +0,0 @@
-#include "dict.hpp"
-
-std::unordered_set<std::string> word_dict;
-
-void load_file() {
-	std::ifstream file("resources/google-10000-english-usa-no-swears.txt");
-	if (file.is_open()) {
-		std::string line;
-		while (std::getline(file, line)) {
-			// using printf() in all tests for consistency
-			//printf("%s", line.c_str());
-			word_dict.insert(line.c_str());
-		}
-		file.close();
-	}
-}

src/dict.hpp

@@ -1,10 +0,0 @@
-#pragma once
-
-#include <fstream>
-#include <unordered_set>
-#include <string>
-
-extern std::unordered_set<std::string> word_dict;
-
-
-void load_file();

src/ergodox.cpp

@@ -205,10 +205,32 @@ bool Ergodox::read() {
 
 		// 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;
 	}

src/ergodox.hpp

@@ -54,6 +54,9 @@ class Ergodox {
 		// 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(
@@ -78,6 +81,12 @@ class Ergodox {
 		// 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

@@ -2,6 +2,7 @@
 #include <cstdint>
 #include <vector>
 #include <stdexcept>
+#include <string>
 // For reading FIFO
 #include <fcntl.h>
 #include <unistd.h>
@@ -11,7 +12,8 @@
 // MPD client
 #include "mpd/client.h"
 
-#include <string>
+// TODO: Include this properly
+#include "/usr/include/hunspell/hunspell.hxx"
 
 // Local files
 #include "utility/bitmap.hpp"
@@ -23,8 +25,6 @@
 
 #include "spdlog/spdlog.h"
 
-#include "dict.hpp"
-
 // TODO:
 //
 // MPD connection error handling
@@ -56,15 +56,273 @@
 const size_t width = 10;
 const size_t height = BOTTOM_SKIP + KB_RESOLUTION + TOP_SKIP;
 
+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,
+};
 
+// 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"?";
+	}
+}
 
 
 int main(int argc, char *argv[]) {
 
-	spdlog::info("Loading dictionary...");
-	load_file();
-	spdlog::info("done!");
-
+	Hunspell* hun = new Hunspell(HUNSPELL_AFF_EN, HUNSPELL_DIC_EN);
 
 	spdlog::set_level(spdlog::level::info);
 
@@ -114,9 +372,15 @@ int main(int argc, char *argv[]) {
 
 	while (1) {
 
+		memset(hid_buf, 0, sizeof(uint8_t) * Dox.packet_size);
+
 		if (Dox.is_connected()) {
 			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);
@@ -136,7 +400,7 @@ int main(int argc, char *argv[]) {
 						h = h>KB_RESOLUTION ? KB_RESOLUTION : h;
 						h = h<0 ? 0 : h;
 
-						hid_buf[i] = h;
+						hid_buf[i + 1] = h;
 					}
 					Dox.write(CMD_ANIM_DATA, hid_buf, Dox.packet_size);
 				}
@@ -158,21 +422,28 @@ int main(int argc, char *argv[]) {
 					case CMD_SPELLCHECK_WORD:
 						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);
 
-						if (word_dict.find(word) == word_dict.end()) {
+						int dp = hun->spell(word);
+						if (!dp) {
 							hid_buf[0] = 0x01;
 							Dox.write(CMD_SPELLCHECK_WORD, hid_buf, Dox.packet_size);
 							spdlog::info("Got typo: \"{0:s}\" not in dict", word);
 						}
+
 						break;
 				}
 			}