C/C++ lib für Sonderzeichenkombinationen (F1-12, +shift, alt, ctrl) als Scancode

[peterfido]

Hallo,

das wird so nicht funktionieren. Dein getchar fragt nur ab, ob eine Taste gedrückt wurde. Bei Sondertasten wie SHIFT und Co. ist es auch wichtig zu wissen, wann diese wieder losgelassen wurden. Die linke SHIFT-Taste hat den Code 42 und die rechte 54.

Mein GCC kompiliert Deinen Code nicht. Da fehlen einige Libs, true sagt ihm nichts und bool kennt er als Typ nicht.

Bei mir wird '/dev/input/event0' als Eingabe angegeben. Der Thread tastatur liest ja ständig die Tastatur ein. Evtl. geht das unter g++ auch so. Mal testen.....
...
...
Ja, geht.
Folgender Code lässt sich mit g++ compilieren:

// Compile with: g++ -o /var/scripte/tastaturtest1 /var/scripte/tastaturtest1.c  -L/usr/local/lib -lpthread
//nice -1 /var/scripte/tastaturtest1 < /dev/input/event0 &

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdint.h>
#include <sys/sysinfo.h>
#include <time.h>
#include <linux/input.h>
#include <pthread.h>

int ziffer=0;
int beenden=2;
int zeit=0;
int shiftl=0;
int shiftr=0;
int strgl=0;
int strgr=0;
int capsl=0;


unsigned char runterfahren(){
    system("halt");
}

unsigned char zahlentaste()
{
    printf("Zahlentaste: %d\n", ziffer);
}

unsigned char tnull()
{
    ziffer=0;
    zahlentaste();
}

unsigned char teins()
{
    ziffer=1;
    zahlentaste();
    
}

unsigned char tzwei()
{
    ziffer=2;
    zahlentaste();
    
}
unsigned char tdrei()
{
    ziffer=3;
    zahlentaste();
    
}
unsigned char tvier()
{
    ziffer=4;
    zahlentaste();
    
}
unsigned char tfuenf()
{
    ziffer=5;
    zahlentaste();
    
}
unsigned char tsechs()
{
    ziffer=6;
    zahlentaste();
    
}
unsigned char tsieben()
{
    ziffer=7;
    zahlentaste();
    
}
unsigned char tacht()
{
    ziffer=8;
    zahlentaste();
    
}
unsigned char tneun()
{
    ziffer=9;
    zahlentaste();
    
}
unsigned char tdel()
{
    printf("Delete\n");
}

unsigned char tnum()
{
printf("Numlock\n");    
}

unsigned char tenter()
{    printf("Enter\n");
    
}
unsigned char tplus()
{
printf("Plus\n");    
}
unsigned char tminus()
{
printf("Minus\n");
}
unsigned char tmal()
{
printf("Mal\n");    
}

unsigned char tgeteilt()
{
    printf("Geteilt\n");    
}

unsigned char tbs()
{
    printf("Backspace\n");
}

unsigned char tq()
{
    beenden=1;
}

unsigned char status()
{
    printf("SHIFTL: %d, SHIFTR: %d, STRGL: %d, STRGR: %d\n",shiftl,shiftr,strgl,strgr);
}

unsigned char tf1()
{
    if(shiftl>=1 || shiftr>=1){
        printf("SHIFT + F1\n");
    }else{
        printf("F1\n");
    }
}

void* tastatur(void *name)
{
    struct input_event event;
    while ((read(0, &event, sizeof(event)) > 0) && (beenden==2) ) {
        if (event.type != EV_KEY) continue;
//        if (event.value != EV_KEY) continue; //Nur Tastendrücke erkennen, kein Loslassen. 0=losgelassen, 1=gedrückt, 2=Wiederholung(lang gedrückt)
    printf("Typ: %d; Wert: %d; Code: %d\n",event.type,event.value,event.code);

        switch (event.code) {
            case 42: shiftl=event.value; break;
            case 54: shiftr=event.value; break;
            case 29: strgl=event.value; break;
            case 97: strgr=event.value; break;
            case 16: tq(); break; //q
            case 82: tnull(); break; //0
            case 79: teins(); break; //1
            case 80: tzwei(); break; //2
            case 81: tdrei(); break; //3
            case 75: tvier(); break; //4
            case 76: tfuenf(); break; //5
            case 77: tsechs(); break; //6
            case 71: tsieben(); break; //7
            case 72: tacht(); break; //8
            case 73: tneun(); break; //9
            case 83: tdel(); break; //DEL
            case 96: tenter(); break; //ENTER
            case 78: tplus(); break; //+
            case 74: tminus(); break; //-
            case 55: tmal(); break; //*
            case 98: tgeteilt(); break; ///
            case 14: tbs(); break; //Backspace
            case 69: tnum(); break; //NumLock
            case 59: tf1(); break; //F1
            case 31: status(); break; //s
        }
    }
    beenden=0;
    pthread_exit((void *) 0);
}

int main()
{
    pthread_t t1;
    struct  sched_param  param;
    pthread_create(&t1, NULL, tastatur, NULL);     // low priority: keyboard monitoring (stop program)
    param.sched_priority = 20;
    pthread_setschedparam(t1, SCHED_RR, &param);
    
/*    if(pthread_create(&t1, NULL, (void *)&tastatur, (void *)"Tastatur") != 0)
    {
      fprintf(stderr, "Fehler bei Tastatur......\n");
      exit(0);
    }  */
    
    while (beenden > 0)
        {     sleep(1);
            zeit++;
            if (zeit==30)
            {
                zeit=0;
                printf("Wieder 30 Sekunden um.\n");
            }
    } 
    usleep(50);
    printf("***********Ende************\n");
    return 0;
}

Vorgehensweise zum Testen wie oben.

[HaWe]

wenn ich jetzt kompiliere, zeigt er mit im LXTerminal an
(F7) ^[[18~

(F1) ^[OP
(shift+F1) ^[01;2P

dazwischen:
wieder 30 Sekunden um.

damit kann ich jetzt nicht so schrecklich viel anfangen...
(wie gesagt, von geany aus kompiliert, ohne Startparameter)

- - - Aktualisiert - - -

ich brauche eigentlich auch nur eine einfache Funktion
int getkeybscancode()

die mir eine nackte Zahl zurückliefert, den rest kann ich selber machen, wenn es für die Tastenkombis keine Tabellen gibt!

[peterfido]

Hallo,

es geht auch mit g++ und ohne Parameter.
Dafür musste ich die Vorgehensweise ändern.

Folgendes Beispiel sollte auch für Dich anpassbar sein. Der Scancode wird in der Variable keybscan abgelegt. Danach kannst Du eine Sub aufrufen oder die Variable in Deiner Mainloop pollen.

// Compile with: g++ -o /var/scripte/tastaturtest1 /var/scripte/tastaturtest1.c  -L/usr/local/lib -lpthread
// /var/scripte/tastaturtest1
// 05.04.2016 - peterfido

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdint.h>
#include <sys/sysinfo.h>
#include <time.h>
#include <linux/input.h>
#include <pthread.h>
#include <errno.h>
#include <termios.h>
#include <signal.h>
#include <sys/types.h>
#include <fcntl.h>
#include <dirent.h>
#include <sys/stat.h>
#include <sys/select.h>

int ziffer=0;
int beenden=2;
int zeit=0;
int shiftl=0;
int shiftr=0;
int shift =0;
int strgl=0;
int strgr=0;
int strg=0;
int capsl=0;
int alt=0;
int altgr=0;
int windows=0;
int kontext=0;
int keybscan=0;

void* thread1Go(void *)
{
    int _TASKS_ACTIVE_=0;
    struct input_event ev[64];
    int fd, rd, value, size = sizeof (struct input_event);

    if ((fd = open ("/dev/input/event0", O_RDONLY)) == -1){
        printf ("Fehler mit Tastatur");
    }else{
        _TASKS_ACTIVE_=1;
    }


    struct input_event event;
    while (_TASKS_ACTIVE_) {
/*         _lastbeat_ = _heartbeat_;
         _heartbeat_ = recvbuf[TERM];   
         if(abs(_heartbeat_ - _lastbeat_) ==0)
              { if(_missedbeats_ <998) _missedbeats_++; }
         else _missedbeats_ = 0;
         _REMOTE_OK_ = _missedbeats_ < 100;
         delay(50);        
*/             
        if ((rd = read (fd, ev, size * 64)) < size)
          printf ("Fehler mit Tastatur");
        
        if (ev[1].type != EV_KEY) continue;
        if (ev[1].value==0){         //Taste losgelassen
                switch (ev[1].code) {
                    case 42: shiftl=0; break;
                    case 54: shiftr=0; break;
                    case 29: strgl=0; break;
                    case 97: strgr=0; break;
                    case 56: alt=0; break;
                    case 125: windows=0; break;
                    case 100: altgr=0; break;
                    case 127: kontext=0; break;
                }
        }else{
            if (ev[1].value==1){            //==1 für nur einen Druck ohne Wiederholung. >=1 für Erkennung von gedrückt gehaltener Taste
                switch (ev[1].code) {
                    case 42: shiftl=1; break;
                    case 54: shiftr=1; break;
                    case 29: strgl=1; break;
                    case 97: strgr=1; break;
                    case 56: alt=1; break;
                    case 125: windows=1; break;
                    case 100: altgr=1; break;
                    case 127: kontext=1; break;
// Ab hier 'normale Tasten'
                    
                    case 1: beenden=0; _TASKS_ACTIVE_=0; break; //ESC
                    default: keybscan=ev[1].code;// Scancode ablegen
                    printf("SHIFTL: %d, SHIFTR: %d, STRGL: %d, STRGR: %d; ",shiftl,shiftr,strgl,strgr);
                    printf("Typ: %d; Wert: %d; Code: %d\n",ev[1].type,ev[1].value,ev[1].code);
                    break;
                }
            }
        }
    }
    beenden=0;
    pthread_exit((void *) 0);
}

int main()
{
    pthread_t thread1;
    struct  sched_param  param;
    

    if(pthread_create(&thread1, NULL, thread1Go, NULL) != 0)
    {
      fprintf(stderr, "Fehler bei Tastatur......\n");
      exit(0);
    }      
    
    param.sched_priority = 20;
    pthread_setschedparam(thread1, SCHED_RR, &param);
    
    beenden=1;
    
    while (beenden > 0)
        {     sleep(1);
            zeit++;
            if (zeit==30)
            {
                zeit=0;
                printf("Wieder 30 Sekunden um.\n");
            }
    } 
    usleep(50);
    printf("***********Ende************\n");
    return 0;
}

Das Threading habe ich soweit von Dir übernommen. Einige Variablen fehlten mir, deren Deklaration muss dann in Deinem Programm wieder raus. Die Heartbeat-Geschichte habe ich einfach komplett auskommentiert. Die brauchst eigentlich nur wieder einkommentieren.

[HaWe]

super nett von dir, vielen Dank für deine Mühe!
War gestern schon zu Bette um die Zeit und bin jetzt auf Arbeit, werde es aber schnellstmöglichst testen, sowie ich wieder zuhause bin!

[peterfido]

Hallo,

reiner Eigennutz. Diese Änderungen werde ich dann auch in meine Projekte bei der nächsten Überarbeitung mit übernehmen. Man kann so prima IR-Fernbedienungen nutzen, welche eine Tastatur / Maus emulieren. Für den Mauspart muss man dann noch ein weiteres Device auslesen. Probleme tauchen erst auf, wenn man keine Tastatur oder mehrere Tastaturen / Mäuse angeschlossen hat, was allerdings bei mir nicht vorkommt.

[HaWe]

so 'n Zufall, genau dafür nutze ichs eigentlich auch, prinzipiell zumindest
ich habe dazu einfach eine Wireless Tastatur am Pi, entweder in normal groß im Testmodus (LogiLink) oder mini (Rii) wenn mobil unterwegs.
Zugegebenermaßen momentan aber beide USB-Dongles gleichzeitig eingestöpselt.... mal gucken, ich zieh die kleine dann erstmal raus....
Eine analoge Joystick-Konsole mit Arduino per BT ist dann aber das Standardwerkzeug zur Fernsteuerung.

[HaWe]

hallo, super, das Programm läuft!
es werden jetzt in 1 Zeile alle modifier plus die gedrückte "echte" Taste angezeigt.

Was hältst du davon, wenn man daraus einen eigenen Scancode generiert?

einfache Taste, Bereich 0...255, so wie jetzt bereits ausgegeben.

Modifier:
shift (links oder rechts, egal): = 1*1024
ctrl (links oder rechts, egal): = 2*1024
alt (links): = 4*1024
altgr (==ctrl+alt) : = 6*1024

diese werden dann zum Rest der gedrückten Tasten dazu addiert.

dann könnte man eine Funktion schreiben, die ausschließlich diesen Scancode berechnet und in einer globalen Variablen speichert.

Dazu könnte ich ein paar Konstanten entwerfen wie z.B.

#define F1     59
#define F2     60
#define F3     61
...

#define F1_shft     59+1024
#define F2_shft     60+1024
#define F3_shft     61+1024
...

#define F1_ctrl     59+2048
#define F2_ctrl     60+2048
#define F3_ctrl     61+2048
...

#define F1_alt      59+4092
#define F2_alt      60+4092
#define F3_alt      61+4092
...

usw

// global)
volatile int _kbscode_=0;


void  getkbscancode() {
   int modkeycode = 0; 
   //...
   // hier jetzt deine Abfrage auf Druck ohne Wiederholung, 
   // dann modkeycode berechnen wie oben aus Summe aus
   // shift (links oder rechts, egal): = 1*1024
   // ctrl (links oder rechts, egal):  = 2*1024
   // alt (links oder rechts, egal):  = 4*1024

  _kbscode_ = ev[1].code + modkeycode  // hier jetzt die Sondertasten als Vielfache von 1024 dazuaddieren
}

sodass man die kbstates abfragen kann per

if(_kbscode_==F1) {...}
else
//...
else
if(_kbscode_==F3_alt) {...}
...
else
if(_kbscode_==F1_shiftalt) {...}
//alternativ)
if(_kbscode_==F1 +1024+4048) {...}

usw...

Die Frage wäre, ob man dann einen eigenen Task dafür spendiert, der ausschließlich void getkbscancode() wiederholt aufruft und so automatisch als keypress-Watcher funktioniert.
Alternativ könnte man diese Funktion auch in jedem anderen, bereits laufenden Task aufrufen, quasi als zusätzliche Unterfunktion.

zwischenstadium:

// Compile with: g++ -o /var/scripte/tastaturtest1 /var/scripte/tastaturtest1.c  -L/usr/local/lib -lpthread
// /var/scripte/tastaturtest1
// 05.04.2016 - peterfido
// variant 06.04.2016 - hawe

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdint.h>
#include <sys/sysinfo.h>
#include <time.h>
#include <linux/input.h>
#include <pthread.h>
#include <errno.h>
#include <termios.h>
#include <signal.h>
#include <sys/types.h>
#include <fcntl.h>
#include <dirent.h>
#include <sys/stat.h>
#include <sys/select.h>

int ziffer=0;
int beenden=2;
int zeit=0;
int shiftl=0;
int shiftr=0;
int shift =0;
int strgl=0;
int strgr=0;
int strg=0;
int capsl=0;
int alt=0;
int altgr=0;
int windows=0;
int kontext=0;
int keybscan=0;

int modscode;
volatile int _kbscode_ ;


void* thread1Go(void *)
{
    int _TASKS_ACTIVE_=0;
    struct input_event ev[64];
    int fd, rd, value, size = sizeof (struct input_event);

    if ((fd = open ("/dev/input/event0", O_RDONLY)) == -1){
        printf ("Fehler mit Tastatur");
    }else{
        _TASKS_ACTIVE_=1;
    }


    struct input_event event;
    while (_TASKS_ACTIVE_) {
             
        if ((rd = read (fd, ev, size * 64)) < size)
          printf ("Fehler mit Tastatur");
       
        if (ev[1].type != EV_KEY) continue;
        if (ev[1].value==0){         //Taste losgelassen
                switch (ev[1].code) {
                    case 42: shiftl=0; break;
                    case 54: shiftr=0; break;
                    case 29: strgl=0; break;
                    case 97: strgr=0; break;
                    case 56: alt=0; break;
                    case 125: windows=0; break;
                    case 100: altgr=0; break;
                    case 127: kontext=0; break;
                }
        }else{
            if (ev[1].value==1){            //==1 für nur einen Druck ohne Wiederholung. >=1 für Erkennung von gedrückt gehaltener Taste
                 modscode = 0;
                 switch (ev[1].code) {
                    case 42: shiftl=1;  break;
                    case 54: shiftr=1;   break;
                    case 29: strgl=1;   break;
                    case 97: strgr=1;  break;
                    case 56: alt=1;  break;
                    case 125: windows=1;   break;
                    case 100: altgr=1; modscode+=(2048+4096); break;
                    case 127: kontext=1; break;
                    
                    
// Ab hier 'normale Tasten'
                   
                    //case 1: beenden=0; _TASKS_ACTIVE_=0; break; //ESC
                    default: keybscan=ev[1].code;// Scancode ablegen
                    
                    if(shiftl || shiftr ) modscode+=1024;   
                    if(strgl  || strgr  ) modscode+=2048;  
                    if(alt)   modscode+=4096;  
                    if(altgr) modscode+=(2048+4096);  
                                    
                    
                    _kbscode_= keybscan + modscode;
                    printf("SHIFTL: %2d, SHIFTR: %2d, STRGL: %2d, STRGR: %2d; ",shiftl,shiftr,strgl,strgr);
                    printf("Typ: %2d; Wert: %2d; Code: %2d scancode=%6d \n",ev[1].type,ev[1].value,ev[1].code, _kbscode_ );
                    break;
                }
            }
        }
    }
    beenden=0;
    pthread_exit((void *) 0);
}

int main()
{
    pthread_t thread1;
    struct  sched_param  param;
   

    if(pthread_create(&thread1, NULL, thread1Go, NULL) != 0)
    {
      fprintf(stderr, "Fehler bei Tastatur......\n");
      exit(0);
    }     
   
    param.sched_priority = 20;
    pthread_setschedparam(thread1, SCHED_RR, &param);
   
    beenden=1;
   
    while (beenden > 0)
        {     sleep(1);
            zeit++;
            if (zeit==30)
            {
                zeit=0;
                printf("Wieder 30 Sekunden um.\n");
            }
    }
    usleep(50);
    printf("***********Ende************\n");
    return 0;
}

was hältst du davon?



ps, Tipp für dich:
Ich habe mir sagen lassen, pthread verlinkt man besser per -pthread statt mit -lpthread.

You should really use -pthread rather than -lpthread as as well as including the library it also sets any other options (which usually on linux means setting -D_REENTRANT as well). So yes, if you use -lpthread then you need -D_REENTRANT otherwise things could go wrong.

Fragen an dich:
1) was verlinkt eigentlich -L/usr/local/lib ?
2) was ist "kontext" und "windows" ?

[peterfido]

Hallo,

L/usr/local/lib gibt noch einen Pfad hinzu, wo der Compiler nach den Libs suchen kann. Evtl. ist es bei g++ gar nicht nötig. Windows ist die Windows-Taste zwischen STRG+Alt und Kontext die Kontextmenütaste zwischen AltGr und STRG auf meiner Tastatur.

Sicher kann man einen eigenen Scancode erstellen. Das kommt auf den Anwendungsfall an. Bei freien Texteingaben ist es einzeln besser, da man die Buchstaben nur einmal abfragt und dann, ob Shift gedrückt ist. Möchte man einen Flipper programmieren, sind separate SHIFTs von Vorteil. Werden STRG UND SHIFT plus eine Taste gedrückt, passt es nicht mehr. Ist eine Makrotastatur vorhanden, empfiehlt es sich noch einen 'Tastaturpuffer' zu integrieren.

In zwei Projekten von mir sind als Bedienung je eine 10er Tastatur dran. Da brauche ich jede Taste inklusive der NumLock Taste.

Je nach Tastatur kann man mehrere Tasten gleichzeitig zuverlässig drücken. Gamer-Tastaturen lassen da normal mehr zu als 08/15 Tastaturen. Es lässt sich prinzipiell auch jede andere Taste als Modifiertaste nutzen. Und so z.B. für Codeeingaben auch die Drück- und Loslasssequenzen auswerten.

Aktuell brauche ich es nicht. Das wär was für die nächsten langen Winterabende (oder einen davon).

Meine Anfänge damit habe ich mit einer PS/2 Tastatur an einem Atmega gemacht. Da kann man dann auch die LEDs der Tastatur ansteuern. Da aber PS/2 bei den IR-Tastaturen und den 10er Tastaturen nicht so gängig ist, habe ich die Tastaturabfrage auf den Raspi ausgelagert.

Das mit den (l)pthread teste ich mal aus. Der von mir gefundene Beispielcode im Netz damals hatte es so gemacht.

Edit: AltGr durch STRG und Alt zu ersetzen klappt oft. Ist aber ein anderer Code. Windows z.B. reicht es nicht AltGr und Entf zu drücken

[HaWe]

ah ja, jetzt hab ischs verstanden mit kontext und windows, hatte ich überlesen.

ps,
2 Zeilen werden offenbar nicht benötigt:

struct input_event event;
und

if (ev[1].type != EV_KEY) continue;

oder?

[peterfido]

Hallo,

auf den ersten Blick sieht es so aus, dass event sich da tatsächlich eingeschlichen hat. Das if schließt aus, dass bei einem 'falschen' Ereignistyp der Rest des Codes durchlaufen wird. Tritt kein Ereignis auf, ist der Typ 0 und dann würde ohne die Abfrage der Rest des Codes durchlaufen werden. So war zumindest der Gedanke. GeDebuggt habe ich nicht, ob es nach der Änderung des Codes noch notwendig ist.

Ansonsten melde ich mich erstmal ab, da ich eine Zeit lang offline sein werde.