NeroReflex/ROGueENEMY
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

keyboard should work now

Browse source
This commit is contained in:
Denis 2023-12-17 02:22:29 +01:00
parent c6ecb53bd3
commit c9354dc357
No known key found for this signature in database
GPG key ID: DD9B63F805CF5C03
7 changed files with 675 additions and 3 deletions
Download patch file Download diff file Expand all files Collapse all files

140
dev_out.c
View file

@ -199,6 +199,140 @@ static void handle_incoming_message_gamepad_set(
} }
} }
static void handle_incoming_message_keyboard_set(
const dev_out_settings_t *const in_settings,
const in_message_keyboard_set_element_t *const msg_payload,
keyboard_status_t *const inout_kbd
) {
switch (msg_payload->type) {
case KEYBOARD_KEY_Q:
inout_kbd->q = msg_payload->value;
break;
case KEYBOARD_KEY_W:
inout_kbd->w = msg_payload->value;
break;
case KEYBOARD_KEY_E:
inout_kbd->e = msg_payload->value;
break;
case KEYBOARD_KEY_R:
inout_kbd->r = msg_payload->value;
break;
case KEYBOARD_KEY_T:
inout_kbd->t = msg_payload->value;
break;
case KEYBOARD_KEY_Y:
inout_kbd->y = msg_payload->value;
break;
case KEYBOARD_KEY_U:
inout_kbd->u = msg_payload->value;
break;
case KEYBOARD_KEY_I:
inout_kbd->i = msg_payload->value;
break;
case KEYBOARD_KEY_O:
inout_kbd->o = msg_payload->value;
break;
case KEYBOARD_KEY_P:
inout_kbd->p = msg_payload->value;
break;
case KEYBOARD_KEY_A:
inout_kbd->a = msg_payload->value;
break;
case KEYBOARD_KEY_S:
inout_kbd->s = msg_payload->value;
break;
case KEYBOARD_KEY_D:
inout_kbd->d = msg_payload->value;
break;
case KEYBOARD_KEY_F:
inout_kbd->f = msg_payload->value;
break;
case KEYBOARD_KEY_G:
inout_kbd->g = msg_payload->value;
break;
case KEYBOARD_KEY_H:
inout_kbd->h = msg_payload->value;
break;
case KEYBOARD_KEY_J:
inout_kbd->j = msg_payload->value;
break;
case KEYBOARD_KEY_K:
inout_kbd->k = msg_payload->value;
break;
case KEYBOARD_KEY_L:
inout_kbd->l = msg_payload->value;
break;
case KEYBOARD_KEY_Z:
inout_kbd->z = msg_payload->value;
break;
case KEYBOARD_KEY_X:
inout_kbd->x = msg_payload->value;
break;
case KEYBOARD_KEY_C:
inout_kbd->c = msg_payload->value;
break;
case KEYBOARD_KEY_V:
inout_kbd->v = msg_payload->value;
break;
case KEYBOARD_KEY_B:
inout_kbd->b = msg_payload->value;
break;
case KEYBOARD_KEY_N:
inout_kbd->n = msg_payload->value;
break;
case KEYBOARD_KEY_M:
inout_kbd->m = msg_payload->value;
break;
case KEYBOARD_KEY_UP:
inout_kbd->up = msg_payload->value;
break;
case KEYBOARD_KEY_DOWN:
inout_kbd->down = msg_payload->value;
break;
case KEYBOARD_KEY_LEFT:
inout_kbd->left = msg_payload->value;
break;
case KEYBOARD_KEY_RIGHT:
inout_kbd->right = msg_payload->value;
break;
case KEYBOARD_KEY_NUM_0:
inout_kbd->num_0 = msg_payload->value;
break;
case KEYBOARD_KEY_NUM_1:
inout_kbd->num_1 = msg_payload->value;
break;
case KEYBOARD_KEY_NUM_2:
inout_kbd->num_2 = msg_payload->value;
break;
case KEYBOARD_KEY_NUM_3:
inout_kbd->num_3 = msg_payload->value;
break;
case KEYBOARD_KEY_NUM_4:
inout_kbd->num_4 = msg_payload->value;
break;
case KEYBOARD_KEY_NUM_5:
inout_kbd->num_5 = msg_payload->value;
break;
case KEYBOARD_KEY_NUM_6:
inout_kbd->num_6 = msg_payload->value;
break;
case KEYBOARD_KEY_NUM_7:
inout_kbd->num_7 = msg_payload->value;
break;
case KEYBOARD_KEY_NUM_8:
inout_kbd->num_8 = msg_payload->value;
break;
case KEYBOARD_KEY_NUM_9:
inout_kbd->num_9 = msg_payload->value;
break;
case KEYBOARD_KEY_LCRTL:
inout_kbd->lctrl = msg_payload->value;
break;
default:
fprintf(stderr, "key not implemented\n");
}
}
static void handle_incoming_message( static void handle_incoming_message(
const dev_out_settings_t *const in_settings, const dev_out_settings_t *const in_settings,
const in_message_t *const msg, const in_message_t *const msg,
@ -222,6 +356,12 @@ static void handle_incoming_message(
&msg->data.mouse_event, &msg->data.mouse_event,
&dev_stats->mouse &dev_stats->mouse
); );
} else if (msg->type == KEYBOARD_SET_ELEMENT) {
handle_incoming_message_keyboard_set(
in_settings,
&msg->data.kbd_set,
&dev_stats->kbd
);
} }
} }

5
devices_status.c
View file

@ -42,6 +42,11 @@ void kbd_status_init(keyboard_status_t *const stats) {
stats->num_9 = 0; stats->num_9 = 0;
stats->num_0 = 0; stats->num_0 = 0;
stats->up = 0;
stats->down = 0;
stats->left = 0;
stats->right = 0;
stats->lctrl = 0; stats->lctrl = 0;
} }

2
devices_status.h
View file

@ -72,6 +72,8 @@ typedef struct keyboard_status {
uint8_t num_1, num_2, num_3, num_4, num_5, num_6, num_7, num_8, num_9, num_0; uint8_t num_1, num_2, num_3, num_4, num_5, num_6, num_7, num_8, num_9, num_0;
uint8_t up, down, left, right;
uint8_t lctrl; uint8_t lctrl;
} keyboard_status_t; } keyboard_status_t;

4
message.h
View file

@ -109,6 +109,10 @@ typedef enum kbd_element {
KEYBOARD_KEY_B, KEYBOARD_KEY_B,
KEYBOARD_KEY_N, KEYBOARD_KEY_N,
KEYBOARD_KEY_M, KEYBOARD_KEY_M,
KEYBOARD_KEY_UP,
KEYBOARD_KEY_DOWN,
KEYBOARD_KEY_LEFT,
KEYBOARD_KEY_RIGHT,
KEYBOARD_KEY_NUM_1, KEYBOARD_KEY_NUM_1,
KEYBOARD_KEY_NUM_2, KEYBOARD_KEY_NUM_2,
KEYBOARD_KEY_NUM_3, KEYBOARD_KEY_NUM_3,

486
rog_ally.c
View file

@ -219,7 +219,7 @@ static int asus_kbd_ev_map(
sscanf(current_mode_str, "%d", &current_mode); sscanf(current_mode_str, "%d", &current_mode);
const int new_mode = get_next_mode(current_mode); const int new_mode = get_next_mode(current_mode);
printf("Current mode is set to %d (read from %s) -- switching to %d", current_mode, current_mode_str, new_mode); printf("Current mode is set to %d (read from %s) -- switching to %d\n", current_mode, current_mode_str, new_mode);
char new_mode_str[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; char new_mode_str[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
snprintf(new_mode_str, sizeof(new_mode_str) - 1, "%d", new_mode); snprintf(new_mode_str, sizeof(new_mode_str) - 1, "%d", new_mode);
@ -236,10 +236,10 @@ static int asus_kbd_ev_map(
} }
} else { } else {
close(gamepad_mode_fd); close(gamepad_mode_fd);
fprintf(stderr, "Unable to read gamepad_mode file to get current mode: %d", errno); fprintf(stderr, "Unable to read gamepad_mode file to get current mode: %d\n", errno);
} }
} else { } else {
fprintf(stderr, "Unable to open gamepad_mode file in read-only mode to get current mode: %d", errno); fprintf(stderr, "Unable to open gamepad_mode file in read-only mode to get current mode: %d\n", errno);
} }
free(tmp_path); free(tmp_path);
@ -283,6 +283,486 @@ static int asus_kbd_ev_map(
} }
}; };
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_Q) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_Q,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_W) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_W,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_E) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_E,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_R) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_R,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_T) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_T,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_Y) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_Y,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_U) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_U,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_I) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_I,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_O) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_O,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_P) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_P,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_A) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_A,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_S) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_S,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_D) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_D,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_F) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_F,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_G) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_G,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_H) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_H,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_J) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_J,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_K) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_K,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_L) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_L,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_Z) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_Z,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_X) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_X,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_C) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_C,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_V) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_V,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_B) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_B,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_N) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_N,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_M) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_M,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_0) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_NUM_0,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_1) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_NUM_1,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_2) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_NUM_2,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_3) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_NUM_3,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_4) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_NUM_4,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_5) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_NUM_5,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_6) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_NUM_6,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_7) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_NUM_7,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_8) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_NUM_8,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_9) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_NUM_9,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_UP) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_UP,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_DOWN) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_DOWN,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_LEFT) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_LEFT,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message;
} else if (e->ev[i].code == KEY_RIGHT) {
const in_message_t current_message = {
.type = KEYBOARD_SET_ELEMENT,
.data = {
.kbd_set = {
.type = KEYBOARD_KEY_RIGHT,
.value = e->ev[i].value
}
}
};
messages[written_msg++] = current_message; messages[written_msg++] = current_message;
} }
} else if (e->ev[i].type == EV_REL) { } else if (e->ev[i].type == EV_REL) {

36
virt_kbd.c
View file

@ -440,6 +440,42 @@ int virt_kbd_send(virt_kbd_t *const kbd, keyboard_status_t *const status, struct
} }
} }
if (status->up != kbd->prev_up) {
tmp_ev.code = KEYBOARD_KEY_UP;
tmp_ev.value = kbd->prev_up = status->up;
if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
res = errno < 0 ? errno : -1 * errno;
goto virt_kbd_send_err;
}
}
if (status->down != kbd->prev_down) {
tmp_ev.code = KEYBOARD_KEY_DOWN;
tmp_ev.value = kbd->prev_down = status->down;
if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
res = errno < 0 ? errno : -1 * errno;
goto virt_kbd_send_err;
}
}
if (status->left != kbd->prev_left) {
tmp_ev.code = KEYBOARD_KEY_LEFT;
tmp_ev.value = kbd->prev_left = status->left;
if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
res = errno < 0 ? errno : -1 * errno;
goto virt_kbd_send_err;
}
}
if (status->right != kbd->prev_right) {
tmp_ev.code = KEYBOARD_KEY_RIGHT;
tmp_ev.value = kbd->prev_right = status->right;
if (write(kbd->fd, &tmp_ev, sizeof(tmp_ev)) != sizeof(struct input_event)) {
res = errno < 0 ? errno : -1 * errno;
goto virt_kbd_send_err;
}
}
#if 0 #if 0
const struct input_event timestamp_ev = { const struct input_event timestamp_ev = {
.code = MSC_TIMESTAMP, .code = MSC_TIMESTAMP,

5
virt_kbd.h
View file

@ -49,6 +49,11 @@ typedef struct virt_kbd {
uint8_t prev_num_9; uint8_t prev_num_9;
uint8_t prev_num_0; uint8_t prev_num_0;
uint8_t prev_up;
uint8_t prev_down;
uint8_t prev_left;
uint8_t prev_right;
uint8_t prev_lctrl; uint8_t prev_lctrl;
} virt_kbd_t; } virt_kbd_t;