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

**peterfido** · 05.04.2016, 20:39

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:

Code:

// 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 · 05.04.2016, 21:05

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** · 05.04.2016, 22:02

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.

Code:

// 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 · 06.04.2016, 08:22

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** · 06.04.2016, 08:58

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 · 06.04.2016, 10:20

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.