Skript über Taste ausführen

[Narkima]

Hallo Raspberry PI Community,

ich stehe vor einem kleinen Problem und zwar:
Ich muss ein Skript bzw. einen Befehl auf der Console über einen externen Taster auslösen. Den externen Taster habe ich bereits gebastelt und via. USB an den PI angeschlossen. Wenn der externe Taster gedrückt wird ist es so, als würde die Taste "A" auf dem ganz normalen Keyboard gedrückt.

Besteht in irgendeinerweise die Möglichkeit, auf der Console, die Taste "A" (oder eine beliebig andere) abzufangen und wenn diese eingegeben wurde, dass ein Skript bzw. ein Befehl oder Cron ausgeführt wird?

Vielen Dank schon jetzt für eure rasche Hilfe.
MfG,
Narkima

[forenbenutzer]

Also um ganz trocken auf deine Frage zu antworten: Ja es besteht eine Möglichkeit.
Vermutlich ist das aber nicht die Antwort, die du hören wolltest.

Sicher musst du dir eine Applikation schreiben, die die Tastatur-Events "überwacht". Ich fürchte fast, ein einfaches Konsolenskript wird da nicht reichen. Mono oder Java könnten dir da gute Dienste erweisen, hier wären es wenige Zeilen Code.

[Yggdrasil]

Hallo,

wenn du Tastatureingaben simulieren willst, könnte dich "xdotool" interessieren. Wie das X im Namen verrät läuft das aber nur in X11.

Tastencodes zu senden ist aber kein guter Ansatz und stattdessen würde ich eine typische Client-Server-Konstruktion vorschlagen.
Dein Hauptprogramm startest du auf der Konsole und wartet dort auf Eingaben. Beim drücken des Tasters startet ein zweites Programm und sendet eine Information an den Server. Für die Datenübergabe gibt es tausend Möglichkeiten. Wenn du nur ein Bash-Skript schreiben willst frage im Serverskript immer nur den Inhalt einer Textdatei ab und mit dem anderen Programm schreibst du da rein.


Gruß Yggdrasil

[li-la]

In einer shell geht das einfach ueber "read".

Mir hab ich ein shell skript geschrieben, in dem ich Tastatureingaben verwende, um die Lautstaerke zu regeln und Radiostationen von 0-9 auszuwaehlen.

Ich wechsel dafuer in ein bestehendes Verzeichnis.

Dort ist in einem Textfile die alte Lautstaerke abgelegt. Der alte Wert wird eingelesen, auf plausible Werte von 0>=x<=100 geprueft. Dann wird die neue Lautstaerke berechnet und gesetzt.

In einer Schleife wird dafuer die Tastatur abgefragt mit "read". Die Lautstaerke wird sofort veraendert und auf den naechsten Tastendruck gewartet.

Erst bei einer meiner Stationstasten von 0-9 wird die Schleife verlassen. Der Wert der Stationstaste wird dann in ein Textfile geschrieben und das Skript endet.

Code: Select all

#/bin/bash

#set volume and get radio station keys 0-9

#set sane default values
cd /var/lib/internet-radio/
TMP="$(pwd)"
REPLY="$(cat $TMP/reply)"
VOL="$(cat $TMP/vol)"
test "$VOL" -lt   0 && VOL=50
test "$VOL" -gt 100 && VOL=50

#echo volume = "$VOL"%
#set last volume
#nmixer -q -s pcm="$VOL"
#amixer info
#amixer controls
#amixer -q -M -c 0 set PCM "$VOL"%
#amixer -q -M -c 0 cset numid=1 "$VOL" unmute
#where n is 0=auto, 1=headphones, 2=hdmi
#amixer -q cset numid=3 0
#amixer -q cset numid=3 1
#amixer -q cset numid=3 2

KEY=''
ACTION=''

until test -n "$ACTION"
  do

  #lynx -dump -nolist http://localhost/cgi-bin/dialog-cgi
  echo
  echo -n "   Lautstärke = $VOL""%   "
  echo -n "Sender =  $(cat last)   "

  #read -n 1 KEY
  read -p 'Taste: ' -n 1 KEY

  echo

  case "$KEY" in
  [0-9])
    ACTION="$KEY"
    ;;
  [+])
    test "$VOL" -le 95 && VOL=$[$VOL + 5]
    nmixer -q -s pcm="$VOL" > /dev/null
    #amixer -q -M -c 0 cset numid=1 "$VOL"% unmute
    echo "$VOL" > "$TMP/vol"
    ;;
  [-])
    test "$VOL" -ge  5 && VOL=$[$VOL - 5]
    nmixer -q -s pcm="$VOL" > /dev/null
    #amixer -q -M -c 0 cset numid=1 "$VOL"% unmute
    echo "$VOL" > "$TMP/vol"
    ;;
  [,.])
    echo
    MPD_HOST=mpd.example.com /usr/bin/mpc next | head -n1
    ;;
  *)
    KEY=''
    ;;
  esac
done

REPLY="$ACTION"
echo $REPLY > $TMP/reply

So hast Du schon mal einen funktionierenden Beispiel code, der leichter anzuapssen ist.

Entweder rufst Du ein eigenes Programm in dem Skript auf, oder kannst Deine Eingaben auch wie ich in meinem Beispiel festhalten und spaeter von anderen Programmen auswerten lassen.

nmixer und amixer sind verschiedene Konsole Programme, die bei Dir evtl. noch nicht vorinstalliert sind. Auswendig weiss ich jetzt nicht in welchen Paketen sie enthalten sind, mit "sudo apt-cache search Programmname" laesst sich das herausfinden und mit "apt-get install" die gefundenen Pakete installieren.

have fun,
cu Frank

[ghans]

@Narkima
AFAIK is bei Raspbian triggerhappy von Haus aus dabei.
Könnte für dich interessant sein.


ghans

[forenbenutzer]

Gut, so ginge es vermutlich über die Konsole, aber so ganz sauber ist das leider nicht. Es käme auch ein bisschen darauf an, wie "sicher" die Anwendung sein soll. In der Konsole drückt man Strg+C und hat die Kommandozeile mit den Rechten des angemeldeten Benutzers. Mit einer "externen" Applikation (u.U. gestartet über ein init-Skript) falle ich im schlimmsten Fall aus der Anwendung raus, ohne dass danach noch schlimmeres passieren kann. Vielleicht denke ich aber auch schon wieder in zu hohen Dimensionen, der "Versuchsaufbau" scheint ja doch eher simpel und experimentell.

[ghp]

Hallo,

das ist ein wenig umständlich ? Den Taster direkt an einen GPIO-Pin anzuschliessen wäre wahrscheinlich einfacher.
Das python- Programm fragt einen GPIO Pin ab, entprellt das Signal und führt einen Prozess (hier shutdown) aus, wenn die Taste gedrückt ist.
Der Code ist - zugegeben - aus einem meiner Programme abgeleitet und nicht getestet.

Code: Select all

import time
import subprocess
import RPi.GPIO as GPIO

class Button(): 
    
    BUTTON = 17 

    def __init__(self): 
        GPIO.setmode(GPIO.BCM)
        GPIO.setwarnings(False)
        
        GPIO.setup(self.BUTTON, GPIO.IN)
        
        
    def swt(self):
        """angenommen, dass ein button mit einem pullup an plus hängt"""
        return GPIO.input(self.BUTTON)
    
    def run(self): 
        btnCnt = 0
        
        buttonPressed = False
        lastButtonPressed = None
        
        while True:
            #
            # Button wird einige Zyklen lange verfolgt, wenn stabil dann buttonPressed setzen oder loeschen
            # 'debounce'
            #   
            if not(self.swt()):
                btnCnt += 1
                if btnCnt > 5:
                    btnCnt = 5
                    buttonPressed = True
            else:
                btnCnt -= 1
                if btnCnt < 0:
                    btnCnt = 0
                    buttonPressed = False
          
            if lastButtonPressed != buttonPressed:
                if buttonPressed:
                    subprocess.Popen(["shutdown", "-h" , "now"])

                else:
                    pass
            lastButtonPressed = buttonPressed

            time.sleep(0.01)

button = Button()
button.run()

Grüsse
Gerhard

PS: wie hast Du den Taster über USB angeschlossen (Schaltung ?) Würde mich interessieren

[naicheben]

Mit AVR über VUSB geht das ganz einfach einen Taster an USB zu bekommen.
Siehe hier: http://www.obdev.at/products/vusb/hidkeys.html

EDIT: noch einfacher ist das natürlich mit den GPIOs zumal der Bastelaufwand deutlich geringer und billiger ist. Nur wenn man noch ein Display dazu braucht, werden langsam die GPIOs knapp auf dem RPi..