qmk_firmware/quantum/process_keycode/process_printer.c

270 lines
7.8 KiB
C
Raw Normal View History

/* Copyright 2016 Jack Humbert
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
2016-10-16 22:03:56 +02:00
#include "process_printer.h"
#include "action_util.h"
#include "uart.h"
2016-10-16 22:03:56 +02:00
2019-08-30 20:19:03 +02:00
bool printing_enabled = false;
uint8_t character_shift = 0;
2016-10-16 22:03:56 +02:00
2017-04-10 09:36:09 +02:00
void enable_printing(void) {
2019-08-30 20:19:03 +02:00
printing_enabled = true;
uart_init(19200);
2016-10-16 22:03:56 +02:00
}
void disable_printing(void) {
printing_enabled = false;
}
2016-10-16 22:03:56 +02:00
uint8_t shifted_numbers[10] = {0x21, 0x40, 0x23, 0x24, 0x25, 0x5E, 0x26, 0x2A, 0x28, 0x29};
// uint8_t keycode_to_ascii[0xFF][2];
2021-11-04 06:22:17 +01:00
// keycode_to_ascii[KC_MINUS] = {0x2D, 0x5F};
2016-10-16 22:03:56 +02:00
void print_char(char c) {
2019-08-30 20:19:03 +02:00
USB_Disable();
uart_write(c);
2019-08-30 20:19:03 +02:00
USB_Init();
2016-10-16 22:03:56 +02:00
}
2017-04-10 09:36:09 +02:00
void print_string(char c[]) {
for (uint8_t i = 0; i < strlen(c); i++)
print_char(c[i]);
2017-04-10 09:36:09 +02:00
}
void print_box_string(const char text[]) {
2019-08-30 20:19:03 +02:00
size_t len = strlen(text);
char out[len * 3 + 8];
out[0] = 0xDA;
for (uint8_t i = 0; i < len; i++) {
out[i + 1] = 0xC4;
}
out[len + 1] = 0xBF;
out[len + 2] = '\n';
2016-10-16 22:03:56 +02:00
2019-08-30 20:19:03 +02:00
out[len + 3] = 0xB3;
for (uint8_t i = 0; i < len; i++) {
out[len + 4 + i] = text[i];
}
out[len * 2 + 4] = 0xB3;
out[len * 2 + 5] = '\n';
2016-10-16 22:03:56 +02:00
2019-08-30 20:19:03 +02:00
out[len * 2 + 6] = 0xC0;
for (uint8_t i = 0; i < len; i++) {
out[len * 2 + 7 + i] = 0xC4;
}
out[len * 3 + 7] = 0xD9;
out[len * 3 + 8] = '\n';
2016-10-16 22:03:56 +02:00
2019-08-30 20:19:03 +02:00
print_string(out);
2016-10-16 22:03:56 +02:00
}
bool process_printer(uint16_t keycode, keyrecord_t *record) {
2019-08-30 20:19:03 +02:00
if (keycode == PRINT_ON) {
enable_printing();
return false;
}
if (keycode == PRINT_OFF) {
disable_printing();
return false;
}
2016-10-16 22:03:56 +02:00
2019-08-30 20:19:03 +02:00
if (printing_enabled) {
switch (keycode) {
case KC_EXLM ... KC_RPRN:
case KC_UNDS:
case KC_PLUS:
case KC_LCBR:
case KC_RCBR:
case KC_PIPE:
case KC_TILD:
keycode &= 0xFF;
2021-11-04 06:22:17 +01:00
case KC_LEFT_SHIFT:
case KC_RIGHT_SHIFT:
2019-08-30 20:19:03 +02:00
if (record->event.pressed) {
character_shift++;
} else {
character_shift--;
}
return false;
break;
}
2016-10-16 22:03:56 +02:00
2019-08-30 20:19:03 +02:00
switch (keycode) {
case KC_F1:
if (record->event.pressed) {
print_box_string("This is a line of text!");
}
return false;
2021-11-04 06:22:17 +01:00
case KC_ESCAPE:
2019-08-30 20:19:03 +02:00
if (record->event.pressed) {
print_char(0x1B);
}
return false;
break;
2021-11-04 06:22:17 +01:00
case KC_SPACE:
2019-08-30 20:19:03 +02:00
if (record->event.pressed) {
print_char(0x20);
}
return false;
break;
case KC_A ... KC_Z:
if (record->event.pressed) {
if (character_shift) {
print_char(0x41 + (keycode - KC_A));
} else {
print_char(0x61 + (keycode - KC_A));
}
}
return false;
break;
case KC_1 ... KC_0:
if (record->event.pressed) {
if (character_shift) {
print_char(shifted_numbers[keycode - KC_1]);
} else {
print_char(0x30 + ((keycode - KC_1 + 1) % 10));
}
}
return false;
break;
2021-11-04 06:22:17 +01:00
case KC_ENTER:
2019-08-30 20:19:03 +02:00
if (record->event.pressed) {
if (character_shift) {
print_char(0x0C);
} else {
print_char(0x0A);
}
}
return false;
break;
2021-11-04 06:22:17 +01:00
case KC_BACKSPACE:
2019-08-30 20:19:03 +02:00
if (record->event.pressed) {
if (character_shift) {
print_char(0x18);
} else {
print_char(0x1A);
}
}
return false;
break;
case KC_DOT:
if (record->event.pressed) {
if (character_shift) {
print_char(0x3E);
} else {
print_char(0x2E);
}
}
return false;
break;
2021-11-04 06:22:17 +01:00
case KC_COMMA:
2019-08-30 20:19:03 +02:00
if (record->event.pressed) {
if (character_shift) {
print_char(0x3C);
} else {
print_char(0x2C);
}
}
return false;
break;
2021-11-04 06:22:17 +01:00
case KC_SLASH:
2019-08-30 20:19:03 +02:00
if (record->event.pressed) {
if (character_shift) {
print_char(0x3F);
} else {
print_char(0x2F);
}
}
return false;
break;
2021-11-04 06:22:17 +01:00
case KC_QUOTE:
2019-08-30 20:19:03 +02:00
if (record->event.pressed) {
if (character_shift) {
print_char(0x22);
} else {
print_char(0x27);
}
}
return false;
break;
2021-11-04 06:22:17 +01:00
case KC_GRAVE:
2019-08-30 20:19:03 +02:00
if (record->event.pressed) {
if (character_shift) {
print_char(0x7E);
} else {
print_char(0x60);
}
}
return false;
break;
2021-11-04 06:22:17 +01:00
case KC_MINUS:
2019-08-30 20:19:03 +02:00
if (record->event.pressed) {
if (character_shift) {
print_char(0x5F);
} else {
print_char(0x2D);
}
}
return false;
break;
2021-11-04 06:22:17 +01:00
case KC_EQUAL:
2019-08-30 20:19:03 +02:00
if (record->event.pressed) {
if (character_shift) {
print_char(0x2B);
} else {
print_char(0x3D);
}
}
return false;
break;
2021-11-04 06:22:17 +01:00
case KC_LEFT_BRACKET:
2019-08-30 20:19:03 +02:00
if (record->event.pressed) {
if (character_shift) {
print_char(0x7B);
} else {
print_char(0x5B);
}
}
return false;
break;
2021-11-04 06:22:17 +01:00
case KC_RIGHT_BRACKET:
2019-08-30 20:19:03 +02:00
if (record->event.pressed) {
if (character_shift) {
print_char(0x7D);
} else {
print_char(0x5D);
}
}
return false;
break;
2021-11-04 06:22:17 +01:00
case KC_BACKSLASH:
2019-08-30 20:19:03 +02:00
if (record->event.pressed) {
if (character_shift) {
print_char(0x7C);
} else {
print_char(0x5C);
}
}
return false;
break;
}
}
return true;
}