Pberndt V4

Direkt zum Inhalt springen

Quellcode hdaps.py

Sourcecode

#!/bin/env python
"""
    vim:fileencoding=iso-8859-1:ft=python
   
    Yet another HDAPS class
    Copyright (c) Phillip Berndt, 2006

    Call this file for some examples.
"""
import time

class HDAPS:
    """
        A basic class for HDAPS access
    """
    __calibration = ()
    HIT_RIGHT = -1
    HIT_LEFT  = 1

    def __init__(self):
        self.calibrate()

    def __valueGet(self, file):
        """
            Load a rotation tuple from HDAPS
        """
        try:
            valueTuple = open("/sys/bus/platform/devices/hdaps/%s" % file, "r").read()[1:-2]
            return map(lambda x: int(x), valueTuple.split(","))
        except:
            raise "HDAPS module not loaded or HDAPS not working"

    def calibrate(self):
        """
            Calibrate the object using the HDAPS calibration
        """
        self.__calibration = self.__valueGet("calibrate")

    def getAbsolute(self):
        """
            Get absolute position
        """
        return self.__valueGet("position")
   
    def getRelative(self, round = 1):
        """
            Get relative position

            The parameter round is for rounding values
            (p.e. round = 5 means every value x returned will be
            x mod 5 = 0)
        """
        position = [0, 0]
        while max(position) is 0:
            position = self.getAbsolute()
        relative = [ int(float(self.__calibration[n] - position[n]) / round) * round for n in (0, 1) ]
        return relative

    def getShock(self, sens = 8):
        """
            Wait until a shock in the X-values is noticed
            (e.g. someone hit the notebook from the side)

            Sens means sensitivity. Higher values means less
            false-positives and more true-negatives.

            This function will ignore anything if the laptop
            if moved too much
        """
        lastValues = []
        while len(lastValues) < 16:
            time.sleep(0.005)
            lastValues.append(self.getRelative(5)[0])
        while 1:
            time.sleep(0.005)
            lastValues.append(self.getRelative(5)[0])
            if len(lastValues) > 16:
                lastValues.pop(0)
            if max(lastValues[8:]) > sens and min(lastValues[8:]) < -sens:
                if (sum(map(lambda x: abs(x), lastValues[:8])) / 8) > 10:
                    continue
                for value in lastValues[8:]:
                    if value is not 0:
                        return value / abs(value)

class Smack:
    """
        A smack class (for smackbook-like applications)
        Override this one ;)
    """
    myHDAPS = None

    def __init__(self):
        self.myHDAPS = HDAPS()

    def loop(self):
        """
            Loop and wait for shocks
        """
        while 1:
            shock = self.myHDAPS.getShock()
            if shock is self.myHDAPS.HIT_RIGHT:
                self.hit_right()
            elif shock is self.myHDAPS.HIT_LEFT:
                self.hit_left()
   
    def hit_right(self):
        """
            This function is called when the laptop
            is hit on the right side
        """
        print "TODO: Implement hit_right()"
   
    def hit_left(self):
        """
            This function is called when the laptop
            is hit on the left side
        """
        print "TODO: Implement hit_left()"

def test():
    """
        Test HDAPS. Shows every change in the
        HDAPS values
    """
    myHDAPS = HDAPS()
    last  = 0
    start = time.clock()
    while 1:
        new = myHDAPS.getRelative(4)[0]
        if new == last:
            continue
        last = new
        print "[%f] %d" % (time.clock() - start, last)
        time.sleep(0.01)

if __name__ == "__main__":
    import os, math, sys

    class Smack_ChangeDesktop(Smack):
        """
            A demo for the smack-class
            (My laptop has special keys, F19 and F20, for desktop change)
        """
        def hit_right(self):
            pipe = os.popen("xmacroplay :0 &>/dev/null", "w")
            pipe.write("KeyStr F19")
            pipe.close()
           
        def hit_left(self):
            pipe = os.popen("xmacroplay :0 &>/dev/null", "w")
            pipe.write("KeyStr F20")
            pipe.close()

    class Smack_Lock(Smack):
        """
            Another demo: Lock screen and unlock after 2 smacks left and
            1 smack right
        """
        time  = 0
        stage = 0
        xlock = 0

        def __init__(self):
            self.xlock = os.spawnvp(os.P_NOWAIT, "xlock", [ "xlock", "-mode", "blank" ])
            Smack.__init__(self)

        def hit_left(self):
            if time.clock() - self.time > 2:
                self.time = time.clock()
                self.stage = 0
            if self.stage is 0:
                self.stage = 1
            elif self.stage is 1:
                self.stage = 2
            elif self.stage is 2:
                pass
            else:
                self.stage = 0
        def hit_right(self):
            if time.clock() - self.time > 2:
                self.time = time.clock()
                self.stage = 0
            if self.stage is 2:
                print "Magic hit-sequence..."
                os.kill(self.xlock, 2) # Int
                time.sleep(1)
                os.kill(self.xlock, 9) # Kill
                sys.exit(0)
            self.stage = 0

    class Smack_ChangeVT(Smack):
        """
            A third demo for the smack-class
            Change VT
        """
        vt = 1

        def hit_right(self):
            self.vt -= 1
            os.system("chvt %d" % self.vt)
           
        def hit_left(self):
            self.vt += 1
            os.system("chvt %d" % self.vt)

    print "Smackbook demo"
    print "A demonstration for this python interface"
    print
    print "Demo 1: Start xlock and kill it upon 2x smack left followed by 1x smack right (requires xlock)"
    print "Demo 2: Call xmacroplay upon smacks to send F19 and F20 (Change desktop, needs to be configured in your WM!)"
    print "Demo 3: chvt on smack (Requires root permissions on most systems)"
    print "Demo 4: Print events"
    print
    print "Please enter your choice: ",
    cmd = 0
    while cmd not in range(1, 5):
        cmd = input()
    if cmd is 1:
        mySmack = Smack_Lock()
    elif cmd is 2:
        mySmack = Smack_ChangeDesktop()
    elif cmd is 3:
        mySmack = Smack_ChangeVT()
    elif cmd is 4:
        mySmack = Smack()
    mySmack.loop()

Download

Dateiname
hdaps.py
Größe
5.07kb