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

alles klar, auf jeden Fall nochmal vielen, vielen Dank, ich kann damit jetzt schon super arbeiten!
\\:D/

- - - Aktualisiert - - -

habs hingekriegt!
die Scanfunktion läuft jetzt in nem eigenen Funktions-Wrap!

Perfekt! Hilft mir jetzt super toll! :cool:

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 strgl=0;
int strgr=0;
int capsl=0;
int alt=0;
int altgr=0;
int windows=0;
int kontext=0;
int keybscan=0;

int modscode;
volatile int _kbscode_ ;

// keyboard dev
int    fkbd;
char * kbdin = "/dev/input/event0";
struct input_event ev[64];


int _TASKS_ACTIVE_= 1;   
   


int getkbscancode() {
        int  rd,  size = sizeof (struct input_event);
       
        if ((rd = read (fkbd, ev, size * 64)) < size)
          printf ("Fehler mit Tastatur");
     
        if (ev[1].type != EV_KEY) return 0;
       
        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'                 
                    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); 
                    if(windows)  modscode+=8192; 
                    if(kontext)  modscode+=16384; 
                                   
                    if(keybscan>0) {
                      _kbscode_= keybscan + modscode;
                      return keybscan;
                    }
                    else
                    return 0 ;
                    //break;
                }
            }
        }
        return 0 ;
}

void* thread6Go(void *)
{
   

    while (_TASKS_ACTIVE_) {
       
        if(getkbscancode()) {
            printf("\nSHIFTL: %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_ );           
        }
    }
    beenden=0;
    pthread_exit((void *) 0);
}

int main()
{
    pthread_t thread6;
    struct  sched_param  param;
   
   
    if ((fkbd = open (kbdin, O_RDONLY)) == -1){
        printf ("Fehler mit Tastatur");
    }
 
 

    if(pthread_create(&thread6, NULL, thread6Go, NULL) != 0)
    {
      fprintf(stderr, "Fehler bei Tastatur......\n");
      exit(0);
    }   
 
    param.sched_priority = 20;
    pthread_setschedparam(thread6, 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;
}

---

so, jetzt habe ich es zusammen mit anderen nützlichen keyboard-Funktionen in eine Lib gepackt:
die Funktion gibt den Scancode von "normalen" Tasten (0-9, a-z, F1-F12, cursor,...) zurück, ansonsten Null bei reinen Modifiern.
In jedem Falle kann man jetzt (bei Null) weiterhin auch sämtliche Modifier isoliert abfragen,
und bei >0 auch alle Events abfangen, die eine " Echte Taste" mit oder ohne Modifier betreffen.
Ebenfalls lassen sich jetzt für die gesamte Kombination eindeutige Scancode-Zahlen als auch diskrete Key-States abfragen, wie
_keyshift_, _keyalt_, _keyctrl_ und _F1_ ... _F12_ (noch ausbaufähig mit home, end, up, dn, ...)
Nun kann man keystrokes abfragen per

int c = getkbscancode();
if (_F1_) {...}
else
if(_F2_) {...}
else
if(_F1_ && _keyshift_) {...}
else
if(_F1_ && _keyshift_ && _keyalt_) {...}

usw...

Buchstabentasten lassen sich auch als scancodes lesen, aber natürlich ebenso, nach wie vor, auch als
c = getchar();



initialisiert wird in main() mit Aufruf von

Code:

---

setupKbdin() ;

---

share and enjoy! :)

Code:

---

#ifndef RPICONIO_H
#define  RPICONIO_H

// courtesy of AndyD, raspberrypi.org forums, and peterfido, roboternetz.de forum
// version 002

#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <termio.h>
#include <unistd.h>

#include <linux/input.h>
#include <termios.h>
#include <signal.h>
#include <sys/types.h>
#include <dirent.h>
#include <sys/stat.h>
#include <sys/select.h>


// keyboard dev
int    fkbd;
char * kbdin = "/dev/input/event0";
struct input_event ev[64];

int shiftl=0;
int shiftr=0;
int _keyshift_=0; // mod keypress state
int ctrll=0;
int ctrlr=0;
int _keyctrl_=0; // mod keypress state
int capsl=0;
int altl=0;
int altgr=0;
int _keyalt_=0;  // mod keypress state
int windows=0;
int kontext=0;
int _keypress_;  // keypress state
int modscode;
volatile int _kbscode_ ;

#define _F1_  59
#define _F2_  60
#define _F3_  61
#define _F4_  62
#define _F5_  63
#define _F6_  64
#define _F7_  65
#define _F8_  66
#define _F9_  67
#define _F10_  68
#define _F11_  69
#define _F12_  70


//*************************************************************
// conio.h - mimics
//*************************************************************

bool kbhit(void)
{
    struct termios original;
    tcgetattr(STDIN_FILENO, &original);

    struct termios term;
    memcpy(&term, &original, sizeof(term));

    term.c_lflag &= ~ICANON;
    tcsetattr(STDIN_FILENO, TCSANOW, &term);

    int characters_buffered = 0;
    ioctl(STDIN_FILENO, FIONREAD, &characters_buffered);

    tcsetattr(STDIN_FILENO, TCSANOW, &original);

    bool pressed = (characters_buffered != 0);

    return pressed;
}

void echoOff(void)
{
    struct termios term;
    tcgetattr(STDIN_FILENO, &term);

    term.c_lflag &= ~ECHO;
    tcsetattr(STDIN_FILENO, TCSANOW, &term);
}

void echoOn(void)
{
    struct termios term;
    tcgetattr(STDIN_FILENO, &term);

    term.c_lflag |= ECHO;
    tcsetattr(STDIN_FILENO, TCSANOW, &term);
}




//*************************************************************
// keyboard scancodes
//*************************************************************

int getkbscancode() {
  int  rd,  size = sizeof (struct input_event);
  int keybscan=0;  // scan code "normal key"
 
 
  if ((rd = read (fkbd, ev, size * 64)) < size)
          printf ("Fehler mit Tastatur");
     
        if (ev[1].type != EV_KEY) return 0;
     
        if (ev[1].value==0){        //Taste losgelassen
                switch (ev[1].code) {
                    case 42: shiftl=0;  break;
                    case 54: shiftr=0;  break;
                    case 29: ctrll=0;    break;
                    case 97: ctrlr=0;    break;
                    case 56: altl=0;    break;
                    case 125: windows=0; break;
                    case 100: altgr=0;  break;
                    case 127: kontext=0; break;
                }
        }
        else
        {
            if (ev[1].value==1){         
            //==1 fuer nur einen Druck ohne Wiederholung. >=1 fuer Erkennung von gedrueckt gehaltener Taste
                modscode = 0;
                switch (ev[1].code) {
                    case 42: shiftl=1;  break;
                    case 54: shiftr=1;  break;
                    case 29: ctrll=1;    break;
                    case 97: ctrlr=1;    break;
                    case 56: altl=1;    break;
                    case 125: windows=1; break;
                    case 100: altgr=1;  break;
                    case 127: kontext=1; break;                 
                 
                    // Ab hier 'normale Tasten'                 
                    default: keybscan=ev[1].code;// Scancode ablegen
                 
                    _keypress_ = keybscan;  // standard keypress state
                    _keyshift_ = 0;        // reset modifier key pressed
                    _keyalt_  = 0;
                    _keyctrl_  = 0;
                                     
                    if(shiftl || shiftr ) { modscode+=1024; _keyshift_=1; }
                    if(ctrll  || ctrlr  ) { modscode+=2048; _keyctrl_=1; }
                    if(altl)              { modscode+=4096; _keyalt_=1; }
                    if(altgr)            { modscode+=(2048+4096);  _keyalt_=1; _keyctrl_=1; }
                    if(windows)          modscode+=8192; 
                    if(kontext)  modscode+=16384;
                                 
                    if(keybscan>0) {
                      _kbscode_= keybscan + modscode;
                      return keybscan;
                    }
                  else  return 0 ;
                  //break;
                }
            }
        }
        return 0 ;
}
 


int setupKbdin() {
  if ((fkbd = open (kbdin, O_RDONLY)) == -1){
        printf ("Fehler mit Tastatur");
        return -1;
  }
  else return 0;
}


#endif

---

OT:
habe immer so ein komisches "powerded by Google" Bild im Posting oben rechts - das engt das Codefenster extrem ein und mach auch editieren extremst schwierig, weil es den Text überlappt. Kann man das nicht abstellen?