KeyState SuperCollider UGen?

this will do:

#include <fcntl.h>
#include <linux/input.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <oscpkt.hh>
#include <libraries/UdpClient/UdpClient.h>

std::string gOscAddress = "/foot"; // OSC address. Message format: <address> <encoderId> <encoderValue>
std::string gDestinationIp = "192.168.7.1"; // 192.168.7.1 is the host computer (if it's a Mac or Linux, it would be 192.168.6.1 if it's Windows).
int gDestinationPort = 5555;
UdpClient sock;

static void sendOsc(const std::string& subPath, int value)
{
	oscpkt::PacketWriter pw;
	pw.init();
	std::string address = gOscAddress + subPath;
	oscpkt::Message msg(address);
	pw.addMessage(msg.pushInt32(value));
	printf("%s %d\n", address.c_str(), value);
	if(pw.isOk())
		sock.send((void*)pw.packetData(), pw.packetSize());
}

int main(){
	if(!sock.setup(gDestinationPort, gDestinationIp.c_str()))
	{
		fprintf(stderr, "Unable to send to %s:%d\n", gDestinationIp.c_str(), gDestinationPort);
		return 1;
	}

	// Variables keyboard control
	struct input_event ev;
	const char *dev = "/dev/input/event1";

	// qwerty keyboard capture
	int fd = open(dev, O_RDONLY);
	if (fd == -1) {
		fprintf(stderr, "Cannot open %s:.\n", dev);
		return -1;
	}
	while (1)
	{
		ssize_t n = read(fd, &ev, sizeof ev);
		if (n < 0) {
			fprintf(stderr, "Error while reading: %d %s\n", errno, strerror(errno));
			return -1;
		} else if (n != sizeof(ev)) {
			fprintf(stderr, "Read unexpected length\n");
			return -1;
		} else {
			if (ev.type == EV_KEY && ev.value == 0 && ev.value <= 2)
			{
				// key released
				sendOsc("/released", ev.code);
			}
			if (ev.type == EV_KEY && ev.value == 1 && ev.value <= 2)
			{
				// key pressed
				sendOsc("", ev.code);
			}
		}
	}
	close(fd); // won't actually get here unless an error occurs
	return 0;
}

This sclang code can be used to test it:

thisProcess.openUDPPort(5555); // the port will stay open until you restart sclang or recompile the class library
o = OSCFunc({ arg msg, time, addr, recvPort; [msg, time, addr, recvPort].postln; }, '/foot');
n = OSCFunc({ arg msg, time, addr, recvPort; [msg, time, addr, recvPort].postln; }, '/foot/released');

notes:

• pressed keys are sent as /foot 67 or similar. This should be the same behaviour you currently had
• released keys are sent as /foot/released 67
• to amend the above behaviours, change the first argument to the two calls to sendOsc().
• as it is above, the program sends to port 5555 on 192.168.7.1, that is on the host computer (if you are on a mac or Linux machine). This is useful for testing, but if you want to pass it to supercollider running on Bela, you will need to change gDestinationIp to 127.0.0.1 or 192.168.7.2 or bela.local.

I have a solution: this works for getting data from a Wacom intuous tablet on Bela and send it to OSC:

/** 
 * How to use on Bela:
 * Create a new C++ project on Bela and replace the content of its render.cpp file with this file.
 * Make sure, compiler constant BELA is defined (the #define BELA statement below is uncommented)
 * Replace the WACOM_DEVICE by the actual device (event), the WACOM is assigned to
*/

#define BELA

#define WACOM_DEVICE "/dev/input/event9"

/**
 * How to read the data in SuperCollider:

thisProcess.openUDPPort(5555); // the port will stay open until you restart sclang or recompile the class library
x = OSCFunc({ arg msg, time, addr, recvPort; [msg, time, addr, recvPort].postln; }, '/wacom/x');
y = OSCFunc({ arg msg, time, addr, recvPort; [msg, time, addr, recvPort].postln; }, '/wacom/y');
pressed = OSCFunc({ arg msg, time, addr, recvPort; [msg, time, addr, recvPort].postln; }, '/wacom/pressed');
misc = OSCFunc({ arg msg, time, addr, recvPort; [msg, time, addr, recvPort].postln; }, '/wacom/misc');

*/

#include <fcntl.h>
#include <linux/input.h>
#include <errno.h>
#include <stdio.h>
#include <string>
#include <unistd.h>

#ifdef BELA 
#include <oscpkt.hh>
#include <libraries/UdpClient/UdpClient.h>

std::string gOscAddress = "/wacom"; // OSC address. Message format: <address> <encoderId> <encoderValue>
std::string gDestinationIp = "192.168.7.1"; // address of the host computer
int gDestinationPort = 5555;
UdpClient sock;
#endif // BELA

static void sendOsc(const std::string& subPath, const double value)
{
#ifdef BELA   
	oscpkt::PacketWriter pw;
	pw.init();
	std::string address = gOscAddress + subPath;
	oscpkt::Message msg(address);
	pw.addMessage(msg.pushDouble(value));
	printf("%s %d\n", address.c_str(), value);
	if(pw.isOk()) {
		sock.send((void*)pw.packetData(), pw.packetSize());
    }
#endif // BELA
}

int main() {
#ifdef BELA
	if(!sock.setup(gDestinationPort, gDestinationIp.c_str()))
	{
		fprintf(stderr, "Unable to send to %s:%d\n", gDestinationIp.c_str(), gDestinationPort);
		return 1;
	}
#endif // BELA

	const char *dev = WACOM_DEVICE;

	// qwerty keyboard capture
	int fd = open(dev, O_RDONLY);
	if (fd == -1) {
		fprintf(stderr, "Cannot open %s:.\n", dev);
		return -1;
	}

    struct input_absinfo absinfo;
    int x_min = 0;
    int x_max = 0;
    int y_min = 0;
    int y_max = 0;

    if (ioctl(fd, EVIOCGABS(ABS_X), &absinfo) == -1) {
        fprintf(stderr, "Failed to get X axis abs info\n");
        return -1;
    }

    x_min = absinfo.minimum;
    x_max = absinfo.maximum;
    printf("X value range [%d, %d]", x_min, x_max);

    if (ioctl(fd, EVIOCGABS(ABS_Y), &absinfo) == -1){
        fprintf(stderr, "Failed to get Y axis abs info\n");
        return -1;
    }

    y_min = absinfo.minimum;
    y_max = absinfo.maximum;
    printf("Y value range [%d, %d]", y_min, y_max);

    double x_position_normalized = 0.0;
    double y_position_normalized = 0.0;
    int event_size = 0;
    struct input_event ev;

	while (1) {
        event_size = read(fd, &ev, sizeof(struct input_event));
        if (event_size != sizeof(struct input_event)) {
            printf("wrong size of event: %d\n", event_size);
            return -1;
        }

        switch (ev.type) {
            case EV_ABS:
                switch (ev.code) {
                    case ABS_X:
                        x_position_normalized = (double) (ev.value - x_min) / (x_max - x_min);   
                        #ifndef BELA
                        printf("X: %f\n", x_position_normalized);
                        #endif // BELA
                        sendOsc("/x", x_position_normalized);
                        break;

                    case ABS_Y:
                        y_position_normalized = (double) (ev.value - y_min) / (y_max - y_min); 
                        #ifndef BELA 
                        printf("Y: %f\n", y_position_normalized);
                        sendOsc("/y", y_position_normalized);
                        #endif // BELA
                        break;
                }
                break;

            case EV_KEY:
                printf("Key pressed: value %d, code %d\n",ev.value, ev.code);
                sendOsc("/pressed", 1.0);
                break;

            case EV_MSC:
                printf("Msc event: value: %d, code %d\n",ev.value, ev.code);
                sendOsc("/misc", 1.0);
                break;
        }

        usleep(10000);
    }
	close(fd); // won't actually get here unless an error occurs

	return 0;
}