Code: Select all
// JTAG disable for PORT F. write JTD bit twice within four cycles.
MCUCR |= (1<<JTD);
MCUCR |= (1<<JTD);
Any advice would be great 
Ellipse wrote: ↑Has anyone managed to get Hasu's 4704 Kishsaver tmk_keyboard converter working with the 107-key 4704 keyboard (keyboard ID A5)? Compiling the code on github without modification worked 95% for the main 62-key section of the 107-key keyboard, but two of my 107-key keyboards have the same keys not emitting values or key codes - the 8* key, the =+ key, and the left CTRL key produce nothing. On my third one, the 7&, -_, and right control key do not emit codes or matrix values. Adding scan codes to the keymap_common.h file did not fix these 3 keys (although they successfully added some codes for the other keys).
The matrix debug option viewed using hid_listen shows no activity for these keys but by pressing 7& and 9(, I can see that the 8* key probably should be column 1 row 1, the += key should be column 6 row 3, and the lower left control key should probably be column 1 row 6). The columns go from 0 through 7 and the rows go from 00 to 0F.
I carefully read through the source code and 4704-specific and TMK general readme files for this github project but cannot figure it out. I read that there is a way to get the 4704 keyboard to list all its break codes by sending the FC "set key flag" command to the keyboard but do not know how to do so (I could not figure out how to use the console option either).
There are other great 4704 converters out there but I would like to get this one working beyond 95%. In my testing over a few days it produced no ghosting or transposed characters while typing at 80+ wpm.
The hid_listen message when plugging in the keyboard:
IBM 4704 Converter
Keyboard ID: A5
Enable break: x36 zc65:rFD c6B:rFD End
(Does FD in the row codes above indicate an error?)
my adjusted keymap_common.h file is below. I added some codes for 103 keys since I got an error when trying to add more than that. Pressing some keys outside of the main 62-key section result in Error: 78 or Error: 79 both with the unmodified compiled hex file and my adjusted one below.Spoiler:
hasu wrote: ↑Ellipse, nice job!
I got a bit talk about 107-key with REVENGE on IRC just a few days ago. This is a coincidence!?
Feel free to ask me. And I'll be happy to improve the docs and my Engrish writing skillI carefully read through the source code and 4704-specific and TMK general readme files for this github project but cannot figure it out. I read that there is a way to get the 4704 keyboard to list all its break codes by sending the FC "set key flag" command to the keyboard but do not know how to do so (I could not figure out how to use the console option either).
See enable_break() in matrix.c, this function does the job.
And I can send you 4704 firmware dis-assembled list via PM for reference, if you want let me know.
FD means 'out of bound' or invalid scan code. You can ignore them, and I also had these on my KSaver IIRC.The hid_listen message when plugging in the keyboard:
IBM 4704 Converter
Keyboard ID: A5
Enable break: x36 zc65:rFD c6B:rFD End
(Does FD in the row codes above indicate an error?)
In 50, 62 and 77-key keyboards 00-77h are valid scan codes and my converter supports those codes only. You need to fix to support scan codes beyond 77h. I guess valid scan codes are 00-7ch but not sure, you will need to do trial and error.my adjusted keymap_common.h file is below. I added some codes for 103 keys since I got an error when trying to add more than that. Pressing some keys outside of the main 62-key section result in Error: 78 or Error: 79 both with the unmodified compiled hex file and my adjusted one below.
These lines should be fixed.
https://github.com/tmk/tmk_keyboard/blo ... trix.c#L73
https://github.com/tmk/tmk_keyboard/blo ... rix.c#L119
hasu wrote: ↑You can apply this patch to see scan codes from 4704.
http://deskthority.net/keyboards-f2/new ... ml#p188064
Code: Select all
diff --git a/converter/ibm4704_usb/matrix.c b/converter/ibm4704_usb/matrix.c index 0bfda2b..aa54ac0 100644 --- a/converter/ibm4704_usb/matrix.c +++ b/converter/ibm4704_usb/matrix.c @@ -118,12 +118,14 @@ uint8_t matrix_scan(void) return 0; } else if ((code&0x78)==0x78) { // 0xFF-F8 and 0x7F-78 is not scancode - xprintf("Error: %0X\n", code); + xprintf("Error: %02X\n", code); matrix_clear(); return 0; } else if (code&0x80) { + dprintf("%02X\n", code); matrix_make(code); } else { + dprintf("%02X\n", code); matrix_break(code); } return 1;
You probably need to issue commands to enable break for those codes in the function:Ellipse wrote: ↑Thanks for your help Hasu! I have tried adjusting lines 73 and 119 with some different values but the 8*, =+, and left CTRL keys still do not work.
Your matrix.c patch above worked perfectly to see the scan codes though! I can see that even the problematic keys on my 107 key 4704 keyboard produce a scan code.
I believe the problem is that for those keys above that do not work, they do not emit a code when releasing the key - a scan code is only emitted when the key is pressed down. All the other working keys emit a code when pressing down on the key and another code when releasing the key. For example, in hid_listen the 7& key emits 88 when pressed and 08 when released, the (problematic) 8* key emits only 09 when pressed and nothing when released, and the 0) key emits 8F when pressed and 0F when released. The problematic =+ key emits only 0D when pressed and nothing when released.
Is there a way to enable the break codes when releasing the problematic keys?
Code: Select all
static void enable_break(void)
{
uint8_t ret;
print("Enable break: ");
// valid scancode: 00-77h
for (uint8_t code = 0; code < 0x78; code++) {
while (ibm4704_send(0x80|code) != 0) {
print("z");
_delay_us(500);
}
_delay_us(2000);
ret = ibm4704_recv();
if (ret != 0xff) {
xprintf("c%02X:r%02X ", code, ret);
}
_delay_us(1000);
}
_delay_us(1000);
while (ibm4704_send(0xFF) != 0) { _delay_us(500); } // End
print("End\n");
}
Code: Select all
Waiting for new device:..
Listening:
USB configured.
M 4704 converter
Keyboard ID: A3
Enable break: c07:rFD c0B:rFD c1E:rFD c2E:rFD c43:rFD c44:rFD c45:rFD c46:rFD c47:rFD c48:rFD c49:rFD c4A:rFD c4B:rFD c4C:rFD c4D:rFD c4E:rFD c4F:rFD c50:rFD c51:rFD c52:rFD c53:rFD c54:rFD c55:rFD c56:rFD c57:rFD c58:rFD c59:rFD c5A:rFD c5B:rFD c5C:rFD c5D:rFD c5E:rFD c5F:rFD c60:rFD c61:rFD c62:rFD c63:rFD c64:rFD c65:rFD c66:rFD c67:rFD c68:rFD c69:rFD c6A:rFD c6B:rFD c6C:rFD c6D:rFD c6E:rFD c6F:rFD c70:rFD c71:rFD c72:rFD c73:rFD c74:rFD c75:rFD c76:rFD c77:rFD End
Keyboard start.
Code: Select all
Waiting for device:...
Listening:
IBM 4704 converter
Keyboard ID: A5
Enable break: x36 zx36 zc65:rFD c6B:rFD c7E:rFD c7F:rFE x36 zcE5:rFD cEB:rFD End
Keyboard start.Code: Select all
/*
Copyright 2014 Jun Wako <wakojun@gmail.com>
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/>.
*/
#include <stdint.h>
#include <stdbool.h>
#include <avr/io.h>
#include <util/delay.h>
#include "action.h"
#include "print.h"
#include "debug.h"
#include "util.h"
#include "ibm4704.h"
#include "matrix.h"
static void matrix_make(uint8_t code);
static void matrix_break(uint8_t code);
static void matrix_clear(void);
/*
* Matrix Array usage:
* IBM 4704 scan codes are assigned into 128(16x8)-cell matrix.
*
* 8bit wide
* +---------+
* 0| |
* :| XX | 00-7F
* f| |
* +---------+
*
* Exceptions:
*/
static uint8_t matrix[MATRIX_ROWS];
// scan code bits 7654 3210
// R:row/C:column -RRR RCCC
#define ROW(code) ((code>>3)&0x0f)
#define COL(code) (code&0x07)
inline
uint8_t matrix_rows(void)
{
return MATRIX_ROWS;
}
inline
uint8_t matrix_cols(void)
{
return MATRIX_COLS;
}
static void enable_break(void)
{
uint8_t ret;
print("Enable break: ");
// valid scancode: 00-77h
for (uint8_t code = 0; code < 0xFA; code++) {
while (ibm4704_send(0x80|code) != 0) {
print("z");
_delay_us(500);
}
_delay_us(2000);
ret = ibm4704_recv();
if (ret != 0xff) {
xprintf("c%02X:r%02X ", code, ret);
}
_delay_us(1000);
}
_delay_us(1000);
while (ibm4704_send(0xFF) != 0) { _delay_us(500); } // End
print("End\n");
}
void matrix_init(void)
{
uint8_t ret;
debug_enable = true;
ibm4704_init();
matrix_clear();
// read keyboard id
while ((ret = ibm4704_recv()) == 0xFF) {
ibm4704_send(0xFE);
_delay_us(100);
}
_delay_ms(2000); // wait for starting up debug console
print("IBM 4704 converter\n");
xprintf("Keyboard ID: %02X\n", ret);
enable_break();
}
/*
* IBM 4704 Scan Code
*/
uint8_t matrix_scan(void)
{
uint8_t code = ibm4704_recv();
if (code==0xFF) {
// Not receivd
return 0;
} else if ((code&0xFA)==0xFA) {
// 0xFF-F8 and 0x7F-78 is not scancode
xprintf("Error: %02X\n", code);
matrix_clear();
return 0;
} else if (code&0x80) {
dprintf("%02X\n", code);
matrix_make(code);
} else {
dprintf("%02X\n", code);
matrix_break(code);
}
return 1;
}
inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & (1<<col));
}
inline
uint8_t matrix_get_row(uint8_t row)
{
return matrix[row];
}
void matrix_print(void)
{
print("\nr/c 01234567\n");
for (uint8_t row = 0; row < matrix_rows(); row++) {
xprintf("%02X: %08b\n", row, bitrev(matrix_get_row(row)));
}
}
inline
static void matrix_make(uint8_t code)
{
matrix[ROW(code)] |= 1<<COL(code);
}
inline
static void matrix_break(uint8_t code)
{
matrix[ROW(code)] &= ~(1<<COL(code));
}
inline
static void matrix_clear(void)
{
for (uint8_t i=0; i < MATRIX_ROWS; i++) matrix[i] = 0x00;
}You better use 7A instead of FA because commands are sent twice when using FA.I found out that my 107-key keyboard emits hexadecimal scan codes up to F9 and so I have adjusted lines 73 and 119 of the matrix.c code to the next hexadecimal value FA.
Enable break: x36 zx36 zc65:rFD c6B:rFD c7E:rFD c7F:rFE x36 zcE5:rFD cEB:rFD End
Code: Select all
diff --git a/converter/ibm4704_usb/matrix.c b/converter/ibm4704_usb/matrix.c
index 0bfda2b..369db9d 100644
--- a/converter/ibm4704_usb/matrix.c
+++ b/converter/ibm4704_usb/matrix.c
@@ -70,7 +70,7 @@ static void enable_break(void)
uint8_t ret;
print("Enable break: ");
// valid scancode: 00-77h
- for (uint8_t code = 0; code < 0x78; code++) {
+ for (uint8_t code = 0; code < 0x7A; code++) {
while (ibm4704_send(0x80|code) != 0) {
print("z");
_delay_us(500);
@@ -116,14 +116,16 @@ uint8_t matrix_scan(void)
if (code==0xFF) {
// Not receivd
return 0;
- } else if ((code&0x78)==0x78) {
- // 0xFF-F8 and 0x7F-78 is not scancode
- xprintf("Error: %0X\n", code);
+ } else if ((code&0x7F) >= 0x7A) {
+ // 0xFF-FA and 0x7F-7A is not scancode
+ xprintf("Error: %02X\n", code);
matrix_clear();
return 0;
} else if (code&0x80) {
+ dprintf("%02X\n", code);
matrix_make(code);
} else {
+ dprintf("%02X\n", code);
matrix_break(code);
}
return 1;
I have those errors too, the code may need to be improved. Do you have pull-up resistors on signal lines? just in case.I also sometimes get x18 and x28 errors when pressing keys.
yes, it is possible but really a last resort.I am thinking that if we are unable to get these keys to emit a release code, as a last resort maybe there could be exceptions added to the code for any problematic keys? For example the exception code could perform this function: "if the scan code 08 is received, then emit 88 as a PRESSED code and then 08 as the RELEASED code" so that the computer thinks the release code was correctly emitted for the key and this key would be emitted to a program. And so on for each problematic key.
Code: Select all
diff --git a/converter/ibm4704_usb/matrix.c b/converter/ibm4704_usb/matrix.c
index 0bfda2b..8ff9955 100644
--- a/converter/ibm4704_usb/matrix.c
+++ b/converter/ibm4704_usb/matrix.c
@@ -69,8 +69,8 @@ static void enable_break(void)
{
uint8_t ret;
print("Enable break: ");
- // valid scancode: 00-77h
- for (uint8_t code = 0; code < 0x78; code++) {
+ // valid scancode: 00-7Ah
+ for (uint8_t code = 0; code < 0x7A; code++) {
while (ibm4704_send(0x80|code) != 0) {
print("z");
_delay_us(500);
@@ -115,15 +115,18 @@ uint8_t matrix_scan(void)
uint8_t code = ibm4704_recv();
if (code==0xFF) {
// Not receivd
+ _delay_ms(10);
return 0;
- } else if ((code&0x78)==0x78) {
- // 0xFF-F8 and 0x7F-78 is not scancode
- xprintf("Error: %0X\n", code);
+ } else if ((code&0x7F) >= 0x7A) {
+ // 0xFF-FA and 0x7F-7A is not scancode
+ xprintf("Error: %02X\n", code);
matrix_clear();
return 0;
} else if (code&0x80) {
+ dprintf("%02X\n", code);
matrix_make(code);
} else {
+ dprintf("%02X\n", code);
matrix_break(code);
}
return 1;
YOu can write action_function in keymap.c for the problematic keys. When it receives scancode from keyboard you can send press and release events to host. This can not work for modifiers. This may work for you or give you a clue at least.Ellipse wrote: ↑ Since those same keys do not work I am wondering how to code the "last resort" option mentioned earlier involving IF statements for the problematic keys? What would be the best way to do that? Then all keys would be working with this IF statement fix.
Code: Select all
/*
* user defined action function
*/
enum function_id {
PROBLEMATIC_KEY,
};
void action_function(keyrecord_t *record, uint8_t id, uint8_t opt)
{
switch (id) {
case PROBLEMATIC_KEY:
// when released
if (!record->event.pressed) {
add_key(opt);
send_keyboard_report();
del_key(opt);
send_keyboard_report();
}
break;
}
}
/*
* Fn action definition
*/
const uint16_t PROGMEM fn_actions[] = {
[0] = ACTION_FUNCTION_OPT(PROBLEMATIC_KEY, KC_7), // for 7& key
[1] = ACTION_FUNCTION_OPT(PROBLEMATIC_KEY, KC_MINUS), // for -_ key
};
Code: Select all
/*
Copyright 2011,2012,2013 Jun Wako <wakojun@gmail.com>
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/>.
*/
#ifndef KEYMAP_COMMON_H
#define KEYMAP_COMMON_H
#include <stdint.h>
#include <stdbool.h>
#include <avr/pgmspace.h>
#include "keycode.h"
#include "action.h"
#include "action_macro.h"
#include "report.h"
#include "print.h"
#include "debug.h"
#include "keymap.h"
// 32*8(256) byte array which converts PS/2 code into USB code
extern const uint8_t keymaps[][MATRIX_ROWS][MATRIX_COLS];
extern const uint16_t fn_actions[];
/* Original keys */
#define KEYMAP( \
K00,K18,K19,K1A,K10,K11,K12,K08,K09,K0A,K0F,K1F,K0D,K0C,K0E,K44,K45,K46, \
K04,K05,K06,K13,K14,K15,K16,K17,K01,K02,K03,K1B,K1C,K1D, K54,K55,K56, \
K20,K21,K22,K23,K24,K25,K26,K27,K28,K29,K2A,K2B,K2C,K2D, K64,K65,K66, \
K30,K3E,K32,K33,K34,K35,K36,K37,K38,K39,K3A,K3B,K3C,K3D, K74,K75,K76, \
K31,K41,K3F, K40, K42,K2F, K77,K67,K71 \
) { \
{ KC_##K00, KC_##K01, KC_##K02, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_NO }, \
{ KC_##K08, KC_##K09, KC_##K0A, KC_NO, KC_##K0C, KC_##K0D, KC_##K0E, KC_##K0F }, \
{ KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17 }, \
{ KC_##K18, KC_##K19, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D, KC_NO, KC_##K1F }, \
{ KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_##K27 }, \
{ KC_##K28, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D, KC_NO, KC_##K2F }, \
{ KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37 }, \
{ KC_##K38, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_##K3F }, \
{ KC_##K40, KC_##K41, KC_##K42, KC_NO, KC_##K44, KC_##K45, KC_##K46, KC_NO }, \
{ KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
{ KC_NO, KC_NO, KC_NO, KC_NO, KC_##K54, KC_##K55, KC_##K56, KC_NO }, \
{ KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
{ KC_NO, KC_NO, KC_NO, KC_NO, KC_##K64, KC_##K65, KC_##K66, KC_##K67 }, \
{ KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
{ KC_NO, KC_##K71, KC_NO, KC_NO, KC_##K74, KC_##K75, KC_##K76, KC_##K77 }, \
{ KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
}
#endif
/*
{ K48, K49, K4A, K4B, K4C, K4D, K4E, K4F }, \
{ K50, K51, K52, K53, K54, K55, K56, K57 }, \
{ K58, K59, K5A, K5B, K5C, K5D, K5E, K5F }, \
{ K60, K61, K62, K63, K64, K65, K66, K67 }, \
{ K68, K69, K6A, K6B, K6C, K6D, K6E, K6F }, \
{ K70, K71, K72, K73, K74, K75, K76, K77 }, \
{ K78, K79, K7A, K7B, K7C, K7D, K7E, K7F }, \
*/Code: Select all
/*
Copyright 2011,2012,2013 Jun Wako <wakojun@gmail.com>
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/>.
*/
#ifndef KEYMAP_COMMON_H
#define KEYMAP_COMMON_H
#include <stdint.h>
#include <stdbool.h>
#include <avr/pgmspace.h>
#include "keycode.h"
#include "action.h"
#include "action_macro.h"
#include "report.h"
#include "print.h"
#include "debug.h"
#include "keymap.h"
// 32*8(256) byte array which converts PS/2 code into USB code
extern const uint8_t keymaps[][MATRIX_ROWS][MATRIX_COLS];
extern const uint16_t fn_actions[];
/* Original keys */
#define KEYMAP( \
K00,K18,K19,K1A,K10,K11,K12,K08,K09,K0A,K0F,K1F,K0D,K0C,K0E,K46,K64,NO,K6B,K6C,K47,K48,K49,K4A, \
K04,K05,K06,K13,K14,K15,K16,K17,K01,K02,K03,K1B,K1C,K1D,K56,K66,K6D,K6E,K6F,K4B,K4C,K4D,K4E, \
K20,K21,K22,K23,K24,K25,K26,K27,K28,K29,K2A,K2B,K2C,K2D,K71,K77,K70,K65,K72,K50,K51,K52,K53, \
K30,K3E,K32,K33,K34,K35,K36,K37,K38,K39,K3A,K3B,K3C,K3D,K44, K74,K75,K76,K5E,K58,K59,K5A, \
K31,K41,K3F, K40, K42,K2F,K54,K55,K78,K67,K79,K5B,K5C,K5D,K57 \
) { \
{ KC_##K00, KC_##K01, KC_##K02, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_NO }, \
{ KC_##K08, KC_##K09, KC_##K0A, KC_NO, KC_##K0C, KC_##K0D, KC_##K0E, KC_##K0F }, \
{ KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17 }, \
{ KC_##K18, KC_##K19, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D, KC_NO, KC_##K1F }, \
{ KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_##K27 }, \
{ KC_##K28, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D, KC_NO, KC_##K2F }, \
{ KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37 }, \
{ KC_##K38, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_##K3F }, \
{ KC_##K40, KC_##K41, KC_##K42, KC_NO, KC_##K44, KC_NO, KC_##K46, KC_##K47 }, \
{ KC_##K48, KC_##K49, KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D, KC_##K4E, KC_NO }, \
{ KC_##K50, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \
{ KC_##K58, KC_##K59, KC_##K5A, KC_##K5B, KC_##K5C, KC_##K5D, KC_##K5E, KC_NO }, \
{ KC_NO, KC_NO, KC_NO, KC_NO, KC_##K64, KC_##K65, KC_##K66, KC_##K67 }, \
{ KC_NO, KC_NO, KC_NO, KC_##K6B, KC_##K6C, KC_##K6D, KC_##K6E, KC_##K6F }, \
{ KC_##K70, KC_##K71, KC_##K72, KC_NO, KC_##K74, KC_##K75, KC_##K76, KC_##K77 }, \
{ KC_##K78, KC_##K79, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
}
#endif
/*
{ K48, K49, K4A, K4B, K4C, K4D, K4E, K4F }, \
{ K50, K51, K52, K53, K54, K55, K56, K57 }, \
{ K58, K59, K5A, K5B, K5C, K5D, K5E, K5F }, \
{ K60, K61, K62, K63, K64, K65, K66, K67 }, \
{ K68, K69, K6A, K6B, K6C, K6D, K6E, K6F }, \
{ K70, K71, K72, K73, K74, K75, K76, K77 }, \
{ K78, K79, K7A, K7B, K7C, K7D, K7E, K7F }, \
*/Code: Select all
/*
Copyright 2013 Jun Wako <wakojun@gmail.com>
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/>.
*/
#include <avr/pgmspace.h>
#include "keymap.h"
#include "report.h"
#include "keycode.h"
#include "action_layer.h"
#include "action.h"
#include "action_macro.h"
#include "debug.h"
static action_t keycode_to_action(uint8_t keycode);
/* converts key to action */
action_t action_for_key(uint8_t layer, key_t key)
{
uint8_t keycode = keymap_key_to_keycode(layer, key);
switch (keycode) {
case KC_FN0 ... KC_FN31:
return keymap_fn_to_action(keycode);
#ifdef BOOTMAGIC_ENABLE
case KC_CAPSLOCK:
case KC_LOCKING_CAPS:
if (keymap_config.swap_control_capslock || keymap_config.capslock_to_control) {
return keycode_to_action(KC_LCTL);
}
return keycode_to_action(keycode);
case KC_LCTL:
if (keymap_config.swap_control_capslock) {
return keycode_to_action(KC_CAPSLOCK);
}
return keycode_to_action(KC_LCTL);
case KC_LALT:
if (keymap_config.swap_lalt_lgui) {
if (keymap_config.no_gui) {
return keycode_to_action(ACTION_NO);
}
return keycode_to_action(KC_LGUI);
}
return keycode_to_action(KC_LALT);
case KC_LGUI:
if (keymap_config.swap_lalt_lgui) {
return keycode_to_action(KC_LALT);
}
if (keymap_config.no_gui) {
return keycode_to_action(ACTION_NO);
}
return keycode_to_action(KC_LGUI);
case KC_RALT:
if (keymap_config.swap_ralt_rgui) {
if (keymap_config.no_gui) {
return keycode_to_action(ACTION_NO);
}
return keycode_to_action(KC_RGUI);
}
return keycode_to_action(KC_RALT);
case KC_RGUI:
if (keymap_config.swap_ralt_rgui) {
return keycode_to_action(KC_RALT);
}
if (keymap_config.no_gui) {
return keycode_to_action(ACTION_NO);
}
return keycode_to_action(KC_RGUI);
case KC_GRAVE:
if (keymap_config.swap_grave_esc) {
return keycode_to_action(KC_ESC);
}
return keycode_to_action(KC_GRAVE);
case KC_ESC:
if (keymap_config.swap_grave_esc) {
return keycode_to_action(KC_GRAVE);
}
return keycode_to_action(KC_ESC);
case KC_BSLASH:
if (keymap_config.swap_backslash_backspace) {
return keycode_to_action(KC_BSPACE);
}
return keycode_to_action(KC_BSLASH);
case KC_BSPACE:
if (keymap_config.swap_backslash_backspace) {
return keycode_to_action(KC_BSLASH);
}
return keycode_to_action(KC_BSPACE);
#endif
default:
return keycode_to_action(keycode);
}
}
/* Macro */
__attribute__ ((weak))
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
{
return MACRO_NONE;
}
/* Function */
/*
* user defined action function
*/
enum function_id {
PROBLEMATIC_KEY,
};
void action_function(keyrecord_t *record, uint8_t id, uint8_t opt)
{
switch (id) {
case PROBLEMATIC_KEY:
// when released
if (!record->event.pressed) {
add_key(opt);
send_keyboard_report();
del_key(opt);
send_keyboard_report();
}
break;
}
}
const uint16_t PROGMEM fn_actions[] = {
[0] = ACTION_LAYER_MOMENTARY(1),
[2] = ACTION_FUNCTION_OPT(PROBLEMATIC_KEY, KC_7), // for 7& key
[3] = ACTION_FUNCTION_OPT(PROBLEMATIC_KEY, KC_MINUS), // for -_ key
[4] = ACTION_FUNCTION_OPT(PROBLEMATIC_KEY, KC_MPLY),
[5] = ACTION_FUNCTION_OPT(PROBLEMATIC_KEY, KC_F3),
[6] = ACTION_FUNCTION_OPT(PROBLEMATIC_KEY, KC_RCTL),
[7] = ACTION_FUNCTION_OPT(PROBLEMATIC_KEY, KC_F10),
[8] = ACTION_FUNCTION_OPT(PROBLEMATIC_KEY, KC_P4),
};
/* translates keycode to action */
static action_t keycode_to_action(uint8_t keycode)
{
action_t action;
switch (keycode) {
case KC_A ... KC_EXSEL:
case KC_LCTRL ... KC_RGUI:
action.code = ACTION_KEY(keycode);
break;
case KC_SYSTEM_POWER ... KC_SYSTEM_WAKE:
action.code = ACTION_USAGE_SYSTEM(KEYCODE2SYSTEM(keycode));
break;
case KC_AUDIO_MUTE ... KC_WWW_FAVORITES:
action.code = ACTION_USAGE_CONSUMER(KEYCODE2CONSUMER(keycode));
break;
case KC_MS_UP ... KC_MS_ACCEL2:
action.code = ACTION_MOUSEKEY(keycode);
break;
case KC_TRNS:
action.code = ACTION_TRANSPARENT;
break;
default:
action.code = ACTION_NO;
break;
}
return action;
}
#ifdef USE_LEGACY_KEYMAP
/*
* Legacy keymap support
* Consider using new keymap API instead.
*/
__attribute__ ((weak))
uint8_t keymap_key_to_keycode(uint8_t layer, key_t key)
{
return keymap_get_keycode(layer, key.row, key.col);
}
/* Legacy keymap support */
__attribute__ ((weak))
action_t keymap_fn_to_action(uint8_t keycode)
{
action_t action = { .code = ACTION_NO };
switch (keycode) {
case KC_FN0 ... KC_FN31:
{
uint8_t layer = keymap_fn_layer(FN_INDEX(keycode));
uint8_t key = keymap_fn_keycode(FN_INDEX(keycode));
if (key) {
action.code = ACTION_LAYER_TAP_KEY(layer, key);
} else {
action.code = ACTION_LAYER_MOMENTARY(layer);
}
}
return action;
default:
return action;
}
}
#endifAs for keymap function you may need to read doc/keymap.md. Add it in your keymap file instead of common/keymap.c and you have to place FN0 and FN1 on '7&' and '-_' key locations of your keymap.I added the problematic key code but nothing changed: it still only emits the release code when the key is pressed and nothing when the key is released. Maybe there is another way to code "if 08 is received, emit 88 pressed code and 08 release code"? Here is my keymap.c file in the common folder:
OK. I'm working on interrupt version now and don't see any significant differences in terms of its result yet. But I have parity errors occasionally and its cause is unclear to me yet.hasu wrote: ↑ Yes, interrupt should be the way to go now, do you want to write code? I think most of existent code can be reused for this. if you are not sure about the protocol I can give you annotated ROM dump list.
Thanks for testing.Ellipse wrote: ↑Thanks Hasu. I downloaded a zip of the new TMK code and ran make to make a new hex file, unaltered just to see if the main 62 key section of my 107 key 4704 keyboard still has skipped keys.
Unfortunately there is more skipping with the updated code than with the original version.
idollar wrote: ↑Hello,
Thanks for all the work !
One question: I have not found in the code any reference to "auxiliary" LEDs. I have procured an IBM 122 without LEDs. I thought that I could add some CapsLoc and NumLock LEDs.
Have I missed something ?
I am also trying to use "hid_listen". I have the Magic key well configured (I can lock the keyboard), CONSOLE_ENABLE=yes but still does not connects. Am I again missing something ?
Many thanks
i$