Skip to content

A truly modular keyboard

C

firmware: media keys over the consumer report (MAPC)

Nathane537420f0a88
diff --git a/firmware/Core/Inc/keymap.h b/firmware/Core/Inc/keymap.h
index b06433b..d132651 100644
--- a/firmware/Core/Inc/keymap.h
+++ b/firmware/Core/Inc/keymap.h
@@ -18,10 +18,16 @@
void KEYMAP_Init(void);
-/* 0 on success, -1 when the table is full. key may be 0 (mods only). */
+enum { KEYMAP_NONE = 0, KEYMAP_KEY = 1, KEYMAP_CONSUMER = 2 };
+
+/* A Keybit maps to a keyboard key or a consumer usage, never both: each
+ * setter replaces whatever was there. 0 on success, -1 when the table is
+ * full. key may be 0 (mods only). */
int KEYMAP_Set(const uint8_t uid[UID_LEN], uint8_t mods, uint8_t key);
-/* 0/0 when unmapped. */
-void KEYMAP_Get(const uint8_t uid[UID_LEN], uint8_t *mods, uint8_t *key);
+int KEYMAP_SetConsumer(const uint8_t uid[UID_LEN], uint16_t usage);
+/* Returns the kind. code is the keyboard usage or the consumer usage,
+ * mods and code are 0 when unmapped. */
+int KEYMAP_Get(const uint8_t uid[UID_LEN], uint8_t *mods, uint16_t *code);
void KEYMAP_Unmap(const uint8_t uid[UID_LEN]);
void KEYMAP_Clear(void);
/* 0 on success (also when flash already matched), -1 on a flash error. */
diff --git a/firmware/Core/Src/keymap.c b/firmware/Core/Src/keymap.c
index 8e3297a..d478784 100644
--- a/firmware/Core/Src/keymap.c
+++ b/firmware/Core/Src/keymap.c
@@ -9,7 +9,7 @@
#define KEYS_PERIOD_MS 5
#define MAP_MAGIC 0x50414D4BUL /* "KMAP" */
-#define MAP_VERSION 1
+#define MAP_VERSION 2 /* 2: entries carry a kind and a 16-bit code */
/* Owned by main.c's Keybit code, refreshed from its own poll calls in the
* main loop. The key task runs from the same loop, so no locking. */
@@ -17,11 +17,13 @@ extern keybit_info_t keybits[KEYBIT_MAX];
extern int keybit_count;
extern volatile uint32_t keybit_changed;
+/* 16 bytes, two flash doublewords. code is the keyboard usage for
+ * KEYMAP_KEY and the consumer page usage for KEYMAP_CONSUMER. */
typedef struct {
uint8_t uid[UID_LEN];
+ uint8_t kind;
uint8_t mods;
- uint8_t key;
- uint8_t pad[2]; /* keeps an entry at two flash doublewords */
+ uint16_t code;
} map_entry_t;
/* Flash image: one header doubleword, then the entries. */
@@ -34,6 +36,8 @@ typedef struct {
static map_image_t map __attribute__((aligned(8)));
static keybit_info_t present[KEYBIT_MAX];
+static uint32_t present_seq[KEYBIT_MAX]; /* press order while held, 0 when up */
+static uint32_t press_counter;
static int present_count;
static char sides[3]; /* last SIDES sent: L, R, T present */
static uint8_t keys_timer_id;
@@ -65,26 +69,38 @@ static int Find(const uint8_t uid[UID_LEN])
return -1;
}
-int KEYMAP_Set(const uint8_t uid[UID_LEN], uint8_t mods, uint8_t key)
+/* A Keybit has one mapping, so setting either kind replaces the other. */
+static int Put(const uint8_t uid[UID_LEN], uint8_t kind, uint8_t mods, uint16_t code)
{
int i = Find(uid);
if (i < 0)
{
if (map.count >= KEYMAP_MAX) return -1;
i = map.count++;
- memset(&map.entries[i], 0xFF, sizeof(map_entry_t));
memcpy(map.entries[i].uid, uid, UID_LEN);
}
+ map.entries[i].kind = kind;
map.entries[i].mods = mods;
- map.entries[i].key = key;
+ map.entries[i].code = code;
return 0;
}
-void KEYMAP_Get(const uint8_t uid[UID_LEN], uint8_t *mods, uint8_t *key)
+int KEYMAP_Set(const uint8_t uid[UID_LEN], uint8_t mods, uint8_t key)
+{
+ return Put(uid, KEYMAP_KEY, mods, key);
+}
+
+int KEYMAP_SetConsumer(const uint8_t uid[UID_LEN], uint16_t usage)
+{
+ return Put(uid, KEYMAP_CONSUMER, 0, usage);
+}
+
+int KEYMAP_Get(const uint8_t uid[UID_LEN], uint8_t *mods, uint16_t *code)
{
int i = Find(uid);
*mods = i < 0 ? 0 : map.entries[i].mods;
- *key = i < 0 ? 0 : map.entries[i].key;
+ *code = i < 0 ? 0 : map.entries[i].code;
+ return i < 0 ? KEYMAP_NONE : map.entries[i].kind;
}
void KEYMAP_Unmap(const uint8_t uid[UID_LEN])
@@ -208,19 +224,25 @@ static void Keys_Task(void)
PROTO_Send("KEY- uid=%s", uid);
}
}
+ uint32_t seq[KEYBIT_MAX];
for (int i = 0; i < keybit_count; i++)
{
const keybit_info_t *old = Find_Keybit(present, present_count, keybits[i].uid);
+ uint8_t was_down = old ? old->key_down : 0;
PROTO_FormatUid(uid, keybits[i].uid);
if (!old) PROTO_Send("KEY+ uid=%s at=%c", uid, keybits[i].at);
- if ((old ? old->key_down : 0) != keybits[i].key_down)
+ if (was_down != keybits[i].key_down)
{
PROTO_Send("PRESS uid=%s down=%d", uid, keybits[i].key_down);
}
+ if (!keybits[i].key_down) seq[i] = 0;
+ else if (!was_down) seq[i] = ++press_counter;
+ else seq[i] = present_seq[old - present];
}
present_count = keybit_count;
memcpy(present, keybits, sizeof(keybit_info_t) * keybit_count);
+ memcpy(present_seq, seq, sizeof(uint32_t) * keybit_count);
char now[3] = {0, 0, 0};
for (int i = 0; i < present_count; i++)
@@ -239,19 +261,31 @@ static void Keys_Task(void)
* seventh turns every slot into ErrorRollOver as HID asks. */
uint8_t report[8] = {0};
int slots = 0;
+ uint16_t consumer = 0; /* most recently pressed consumer key wins */
+ uint32_t consumer_seq = 0;
for (int i = 0; i < present_count; i++)
{
if (!present[i].key_down) continue;
int m = Find(present[i].uid);
if (m < 0) continue; /* unmapped Keybits send nothing */
+ if (map.entries[m].kind == KEYMAP_CONSUMER)
+ {
+ if (present_seq[i] > consumer_seq)
+ {
+ consumer_seq = present_seq[i];
+ consumer = map.entries[m].code;
+ }
+ continue;
+ }
report[0] |= map.entries[m].mods;
- uint8_t key = map.entries[m].key;
+ uint8_t key = (uint8_t)map.entries[m].code;
if (!key) continue;
if (slots < 6) report[2 + slots] = key;
else memset(&report[2], 0x01, 6);
slots++;
}
HIDSAPP_SendKeyboard(report);
+ HIDSAPP_SendConsumer(consumer);
}
static void Keys_Tick(void)
diff --git a/firmware/Core/Src/proto.c b/firmware/Core/Src/proto.c
index e06b9be..1b477ef 100644
--- a/firmware/Core/Src/proto.c
+++ b/firmware/Core/Src/proto.c
@@ -128,17 +128,40 @@ static void Handle_Line(char *cmd)
PROTO_FormatUid(uid_s, uid);
PROTO_Send("OK MAP uid=%s", uid_s);
}
+ else if (strcmp(cmd, "MAPC") == 0)
+ {
+ uint8_t usage[2];
+ if (Arg_Uid(args, uid) || Arg_Hex(args, "usage", 4, usage))
+ {
+ PROTO_Send("ERR usage: MAPC uid=<24hex> usage=<4hex>");
+ return;
+ }
+ if (KEYMAP_SetConsumer(uid, (uint16_t)(usage[0] << 8 | usage[1])) != 0)
+ {
+ PROTO_Send("ERR keymap full");
+ return;
+ }
+ PROTO_FormatUid(uid_s, uid);
+ PROTO_Send("OK MAPC uid=%s", uid_s);
+ }
else if (strcmp(cmd, "MAP?") == 0)
{
- uint8_t mods, key;
+ uint8_t mods;
+ uint16_t code;
if (Arg_Uid(args, uid))
{
PROTO_Send("ERR usage: MAP? uid=<24hex>");
return;
}
- KEYMAP_Get(uid, &mods, &key);
PROTO_FormatUid(uid_s, uid);
- PROTO_Send("MAP uid=%s mods=%02X key=%02X", uid_s, mods, key);
+ if (KEYMAP_Get(uid, &mods, &code) == KEYMAP_CONSUMER)
+ {
+ PROTO_Send("MAPC uid=%s usage=%04X", uid_s, code);
+ }
+ else
+ {
+ PROTO_Send("MAP uid=%s mods=%02X key=%02X", uid_s, mods, code);
+ }
}
else if (strcmp(cmd, "UNMAP") == 0)
{
diff --git a/firmware/test/proto_test.c b/firmware/test/proto_test.c
index 4b4b2f4..314ce32 100644
--- a/firmware/test/proto_test.c
+++ b/firmware/test/proto_test.c
@@ -14,7 +14,7 @@ static char out[2048];
void NUS_Write(const char *data, uint16_t len) { strncat(out, data, len); }
-static struct { uint8_t uid[UID_LEN], mods, key; } table[KEYMAP_MAX];
+static struct { uint8_t uid[UID_LEN], kind, mods; uint16_t code; } table[KEYMAP_MAX];
static int n;
static keybit_info_t present[2];
@@ -23,17 +23,20 @@ static int find(const uint8_t *uid)
for (int i = 0; i < n; i++) if (!memcmp(table[i].uid, uid, UID_LEN)) return i;
return -1;
}
-int KEYMAP_Set(const uint8_t *uid, uint8_t mods, uint8_t key)
+static int put(const uint8_t *uid, uint8_t kind, uint8_t mods, uint16_t code)
{
int i = find(uid);
if (i < 0) { if (n == KEYMAP_MAX) return -1; i = n++; memcpy(table[i].uid, uid, UID_LEN); }
- table[i].mods = mods; table[i].key = key;
+ table[i].kind = kind; table[i].mods = mods; table[i].code = code;
return 0;
}
-void KEYMAP_Get(const uint8_t *uid, uint8_t *mods, uint8_t *key)
+int KEYMAP_Set(const uint8_t *uid, uint8_t mods, uint8_t key) { return put(uid, KEYMAP_KEY, mods, key); }
+int KEYMAP_SetConsumer(const uint8_t *uid, uint16_t usage) { return put(uid, KEYMAP_CONSUMER, 0, usage); }
+int KEYMAP_Get(const uint8_t *uid, uint8_t *mods, uint16_t *code)
{
int i = find(uid);
- *mods = i < 0 ? 0 : table[i].mods; *key = i < 0 ? 0 : table[i].key;
+ *mods = i < 0 ? 0 : table[i].mods; *code = i < 0 ? 0 : table[i].code;
+ return i < 0 ? KEYMAP_NONE : table[i].kind;
}
void KEYMAP_Unmap(const uint8_t *uid) { int i = find(uid); if (i >= 0) table[i] = table[--n]; }
void KEYMAP_Clear(void) { n = 0; }
@@ -68,7 +71,23 @@ int main(void)
expect("MAP? uid=" U "\n", "MAP uid=" U " mods=01 key=00\n");
expect("UNMAP uid=" U "\n", "OK UNMAP uid=" U "\n");
expect("MAP? uid=" U "\n", "MAP uid=" U " mods=00 key=00\n");
+
+ /* consumer keys: MAPC and MAP replace each other */
+ expect("MAPC uid=" U " usage=00CD\n", "OK MAPC uid=" U "\n");
+ assert(table[0].kind == KEYMAP_CONSUMER && table[0].code == 0x00CD);
+ expect("MAP? uid=" U "\n", "MAPC uid=" U " usage=00CD\n");
+ expect("MAP uid=" U " mods=00 key=04\n", "OK MAP uid=" U "\n");
+ expect("MAP? uid=" U "\n", "MAP uid=" U " mods=00 key=04\n");
+ expect("MAPC uid=" U " usage=00e9\n", "OK MAPC uid=" U "\n");
+ expect("MAP? uid=" U "\n", "MAPC uid=" U " usage=00E9\n");
+ assert(n == 1);
+ expect("UNMAP uid=" U "\n", "OK UNMAP uid=" U "\n");
+ expect("MAP? uid=" U "\n", "MAP uid=" U " mods=00 key=00\n");
+ expect("MAPC uid=" U " usage=E2\n", "ERR usage: MAPC uid=<24hex> usage=<4hex>\n");
+ expect("MAPC uid=" U "\n", "ERR usage: MAPC uid=<24hex> usage=<4hex>\n");
+ expect("MAPC uid=" U " usage=00E2\n", "OK MAPC uid=" U "\n");
expect("CLEAR\n", "OK CLEAR\n");
+ assert(n == 0);
expect("SAVE\n", "OK SAVE\n");
/* chunked like 20 byte BLE writes */
@@ -87,6 +106,7 @@ int main(void)
n = KEYMAP_MAX;
expect("MAP uid=FFFFFFFFFFFFFFFFFFFFFFFF mods=00 key=04\n", "ERR keymap full\n");
+ expect("MAPC uid=FFFFFFFFFFFFFFFFFFFFFFFF usage=00CD\n", "ERR keymap full\n");
char longline[300];
memset(longline, 'A', sizeof(longline) - 2);