You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Kaleidoscope/ArduinoKeyboard.ino

490 lines
11 KiB

// Do not remove the include below
#include "ArduinoKeyboard.h"
11 years ago
// Copyright 2013 Jesse Vincent <jesse@fsck.com>
// All Rights Reserved. (To be licensed under an opensource license
// before the release of the keyboard.io model 01
/**
* TODO:
add mouse inertia
add series-of-character macros
add series of keystroke macros
11 years ago
use a lower-level USB API
*
**/
#include "ArduinoKeyboard.h"
#include <EEPROM.h> // Don't need this for CLI compilation, but do need it in the IDE
#include <digitalWriteFast.h>
11 years ago
11 years ago
void setup_matrix()
{
11 years ago
//blank out the matrix.
for (byte col = 0; col < COLS; col++) {
for (byte row = 0; row < ROWS; row++) {
matrixState[row][col] = 0;
11 years ago
}
}
}
void reset_matrix()
{
for (byte col = 0; col < COLS; col++) {
for (byte row = 0; row < ROWS; row++) {
matrixState[row][col] <<= 1;
11 years ago
}
}
}
void set_keymap(Key keymapEntry, byte matrixStateEntry) {
if (keymapEntry.flags & SWITCH_TO_KEYMAP) {
// this logic sucks. there is a better way TODO this
if (! (keymapEntry.flags ^ ( MOMENTARY | SWITCH_TO_KEYMAP))) {
if (key_is_pressed(matrixStateEntry)) {
if ( keymapEntry.rawKey == KEYMAP_NEXT) {
active_keymap++;
} else if ( keymapEntry.rawKey == KEYMAP_PREVIOUS) {
active_keymap--;
} else {
active_keymap = keymapEntry.rawKey;
}
}
} else if (! (keymapEntry.flags ^ ( SWITCH_TO_KEYMAP))) {
// switch keymap and stay there
if (key_toggled_on(matrixStateEntry)) {
active_keymap = primary_keymap = keymapEntry.rawKey;
save_primary_keymap(primary_keymap);
#ifdef DEBUG_SERIAL
Serial.print("keymap is now:");
Serial.print(active_keymap);
#endif
}
}
}
}
11 years ago
void scan_matrix()
{
//scan the Keyboard matrix looking for connections
for (byte row = 0; row < ROWS; row++) {
digitalWriteFast(rowPins[row], LOW);
for (byte col = 0; col < COLS; col++) {
//If we see an electrical connection on I->J,
if (digitalReadFast(colPins[col])) {
matrixState[row][col] |= 0;
} else {
matrixState[row][col] |= 1;
}
// while we're inspecting the electrical matrix, we look
// to see if the Key being held is a firmware level
// metakey, so we can act on it, lest we only discover
// that we should be looking at a seconary Keymap halfway
// through the matrix scan
11 years ago
set_keymap(keymaps[active_keymap][row][col], matrixState[row][col]);
11 years ago
}
digitalWriteFast(rowPins[row], HIGH);
}
}
// Command mode
//
void command_reboot_bootloader() {
Keyboard.println("Rebooting to bootloader");
Serial.end();
// Set the magic bits to get a Caterina-based device
// to reboot into the bootloader and stay there, rather
// than run move onward
//
// These values are the same as those defined in
// Caterina.c
uint16_t bootKey = 0x7777;
uint16_t *const bootKeyPtr = (uint16_t *)0x0800;
// Stash the magic key
*bootKeyPtr = bootKey;
// Set a watchdog timer
wdt_enable(WDTO_120MS);
while(1) {} // This infinite loop ensures nothing else
// happens before the watchdog reboots us
}
void command_plugh() {
commandMode = !commandMode;
if (commandMode) {
Keyboard.println("");
Keyboard.println("Entering command mode!");
} else {
Keyboard.println("Leaving command mode!");
Keyboard.println("");
}
}
void setup_command_mode() {
commandBufferSize=0;
commandMode = false;
commandPromptPrinted = false;
}
boolean command_ends_in_return() {
if (
commandBuffer[commandBufferSize-1] == KEY_ENTER ||
commandBuffer[commandBufferSize-1] == KEY_RETURN ) {
return true;
} else {
return false;
}
}
boolean is_command_buffer(byte* myCommand) {
if (!command_ends_in_return()) {
return false;
}
int i = 0;
do {
if (commandBuffer[i] != myCommand[i]) {
return false;
}
} while (myCommand[++i] != NULL);
return true;
}
void process_command_buffer(){
if (!command_ends_in_return()) {
return;
}
// This is the only command we might want to execute when
// we're not in command mode, as it's the only way to toggle
// command mode on
static byte cmd_plugh[] = {KEY_P,KEY_L,KEY_U,KEY_G,KEY_H,NULL};
if (is_command_buffer(cmd_plugh)) {
command_plugh();
}
// if we've toggled command mode off, get out of here.
if (!commandMode) {
commandBufferSize=0;
return;
}
// Handle all the other commands here
static byte cmd_reboot_bootloader[] = { KEY_B, KEY_O, KEY_O, KEY_T, KEY_L, KEY_O, KEY_A, KEY_D, KEY_E, KEY_R, NULL};
static byte cmd_version[] = { KEY_V, KEY_E, KEY_R, KEY_S, KEY_I, KEY_O, KEY_N, NULL};
if(is_command_buffer(cmd_reboot_bootloader)) {
command_reboot_bootloader();
} else if (is_command_buffer(cmd_version)) {
Keyboard.println("");
Keyboard.print("This is Keyboardio Firmware ");
Keyboard.println(VERSION);
}
if (!commandPromptPrinted ){
Keyboard.print(">>> ");
commandPromptPrinted = true;
commandBufferSize=0;
}
}
void setup()
{
wdt_disable();
//usbMaxPower = 100;
Keyboard.begin();
Mouse.begin();
setup_command_mode();
setup_matrix();
setup_pins();
Serial.begin(9600);
primary_keymap = load_primary_keymap();
11 years ago
}
String myApp;
void loop()
{
if(Serial.available()) {
myApp = Serial.readString();
myApp.trim();
}
active_keymap = primary_keymap;
scan_matrix();
11 years ago
send_key_events();
reset_matrix();
reset_key_report();
11 years ago
}
void save_primary_keymap(byte keymap)
{
EEPROM.write(EEPROM_KEYMAP_LOCATION, keymap);
}
byte load_primary_keymap()
{
byte keymap = EEPROM.read(EEPROM_KEYMAP_LOCATION);
if (keymap >= KEYMAPS ) {
return 0; // undefined positions get saved as 255
}
return keymap;
}
// Debugging Reporting
//
void report_matrix()
{
#ifdef DEBUG_SERIAL
if (reporting_counter++ % 100 == 0 ) {
for (byte row = 0; row < ROWS; row++) {
for (byte col = 0; col < COLS; col++) {
Serial.print(matrixState[row][col], HEX);
Serial.print(", ");
}
Serial.println("");
}
Serial.println("");
}
#endif
}
void report(byte row, byte col, boolean value)
{
#ifdef DEBUG_SERIAL
Serial.print("Detected a change on ");
Serial.print(col);
Serial.print(" ");
Serial.print(row);
Serial.print(" to ");
Serial.print(value);
Serial.println(".");
#endif
}
11 years ago
//
// Key Reports
//
11 years ago
void release_keys_not_being_pressed()
{
// we use charsReportedLastTime to figure out what we might
// not be holding anymore and can now release. this is
11 years ago
// destructive to charsReportedLastTime
for (byte i = 0; i < KEYS_HELD_BUFFER; i++) {
// for each key we were holding as of the end of the last cycle
// see if we're still holding it
// if we're not, call an explicit Release
if (charsReportedLastTime[i] != 0x00) {
// if there _was_ a character in this slot, go check the
// currently held characters
for (byte j = 0; j < KEYS_HELD_BUFFER; j++) {
if (charsReportedLastTime[i] == charsBeingReported[j]) {
// if's still held, we don't need to do anything.
charsReportedLastTime[i] = 0x00;
break;
}
}
}
}
for (byte i = 0; i < KEYS_HELD_BUFFER; i++) {
if (charsReportedLastTime[i] != 0x00) {
Keyboard.release(charsReportedLastTime[i]);
}
}
}
void record_key_being_pressed(byte character)
{
for (byte i = 0; i < KEYS_HELD_BUFFER; i++) {
// todo - deal with overflowing the 12 key buffer here
if (charsBeingReported[i] == 0x00) {
charsBeingReported[i] = character;
break;
}
}
}
void reset_key_report()
{
for (byte i = 0; i < KEYS_HELD_BUFFER; i++) {
charsReportedLastTime[i] = charsBeingReported[i];
charsBeingReported[i] = 0x00;
}
}
// Sending events to the usb host
void handle_synthetic_key_press(byte switchState, Key mappedKey) {
if (mappedKey.flags & IS_CONSUMER) {
if (key_toggled_on (switchState)) {
Keyboard.consumerControl(mappedKey.rawKey);
}
}
else if (mappedKey.flags & IS_SYSCTL) {
if (key_toggled_on (switchState)) {
Keyboard.systemControl(mappedKey.rawKey);
}
}
else if (mappedKey.flags & IS_MACRO) {
if (key_toggled_on (switchState)) {
if (mappedKey.rawKey == 1) {
Serial.print("Keyboard.IO keyboard driver v0.00");
11 years ago
}
}
} else if (mappedKey.rawKey == KEY_MOUSE_BTN_L
|| mappedKey.rawKey == KEY_MOUSE_BTN_M
|| mappedKey.rawKey == KEY_MOUSE_BTN_R) {
if (key_toggled_on (switchState)) {
Mouse.press(mappedKey.rawKey);
end_warping();
11 years ago
} else if (key_is_pressed(switchState)) {
} else if (Mouse.isPressed(mappedKey.rawKey) ) {
Mouse.release(mappedKey.rawKey);
}
}
}
void send_key_events()
{
//for every newly pressed button, figure out what logical key it is and send a key down event
// for every newly released button, figure out what logical key it is and send a key up event
// TODO:switch to sending raw HID packets
// really, these are signed small ints
char x = 0;
char y = 0;
for (byte row = 0; row < ROWS; row++) {
for (byte col = 0; col < COLS; col++) {
byte switchState = matrixState[row][col];
Key mappedKey = keymaps[active_keymap][row][col];
11 years ago
if (mappedKey.flags & MOUSE_KEY ) {
if (mappedKey.rawKey & MOUSE_WARP) {
if (key_toggled_on(switchState)) {
warp_mouse(mappedKey);
}
} else {
handle_mouse_key_press(switchState, mappedKey, x, y);
}
11 years ago
} else if (mappedKey.flags & SYNTHETIC_KEY) {
handle_synthetic_key_press(switchState, mappedKey);
11 years ago
}
else {
if (String("Slack") == myApp) {
if (key_is_pressed(switchState)) {
record_key_being_pressed(mappedKey.rawKey);
if (key_toggled_on (switchState)) {
Keyboard.print("Never gonna give you up!");
}
}
} else {
11 years ago
if (key_is_pressed(switchState)) {
record_key_being_pressed(mappedKey.rawKey);
if (key_toggled_on (switchState)) {
press_key(mappedKey);
11 years ago
}
} else if (key_toggled_off (switchState)) {
release_key(mappedKey);
11 years ago
}
}
11 years ago
}
}
}
handle_mouse_movement(x, y);
release_keys_not_being_pressed();
}
void press_key(Key mappedKey) {
Keyboard.press(mappedKey.rawKey);
if (commandBufferSize>=31){
commandBufferSize=0;
}
commandBuffer[commandBufferSize++]=mappedKey.rawKey;
if( mappedKey.rawKey == KEY_ENTER ||
mappedKey.rawKey == KEY_RETURN ) {
commandPromptPrinted=false;
process_command_buffer();
commandBufferSize=0;
}
}
void release_key(Key mappedKey){
Keyboard.release(mappedKey.rawKey);
}
11 years ago
// Hardware initialization
void setup_pins()
{
setup_output_pins();
setup_input_pins();
}
void setup_output_pins() {
11 years ago
//set up the row pins as outputs
for (byte row = 0; row < ROWS; row++) {
pinMode(rowPins[row], OUTPUT);
digitalWriteFast(rowPins[row], HIGH);
11 years ago
}
}
void setup_input_pins {
11 years ago
for (byte col = 0; col < COLS; col++) {
pinMode(colPins[col], INPUT);
digitalWriteFast(colPins[col], HIGH);
11 years ago
//drive em high by default s it seems to be more reliable than driving em low
}
}