Posts by mattes1007

lsusb
Bus 001 Device 007: ID 1234:4321 Brain Actuated Technologies Human Interface Device

dmesg
[29934.438216] usb 1-1.3: New USB device found, idVendor=1234, idProduct=4321
[29934.438229] usb 1-1.3: New USB device strings: Mfr=1, Product=2, SerialNumber=3
[29934.438238] usb 1-1.3: Product: AFANDA BARCODE
[29934.438246] usb 1-1.3: Manufacturer: Barcode
[29934.438254] usb 1-1.3: SerialNumber: AFANDBARCODE
[29934.441679] input: Barcode AFANDA BARCODE as /devices/platform/soc/3f980000.usb/usb1/1-1/1-1.3/1-1.3:1.0/0003:1234:4321.0003/input/input2
[29934.505701] hid-generic 0003:1234:4321.0003: input,hidraw0: USB HID v1.00 Keyboard [Barcode AFANDA BARCODE] on usb-3f980000.usb-1.3/input0

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import time
import os
import signal
import MySQLdb
import RPi.GPIO as GPIO
import MFRC522
import termios
from threading import Timer
from termcolor import colored, cprint
GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
GPIO.setup(15, GPIO.OUT)
GPIO.output(15, GPIO.HIGH)
time.sleep(0.1)
GPIO.output(15, GPIO.LOW)
GPIO.setup(12, GPIO.OUT)
GPIO.setup(16, GPIO.OUT)
GPIO.setup(18, GPIO.OUT)

# Connect to the Database
db = MySQLdb.connect(host="localhost",
                     user="root", 
                     passwd="root",
                     db="pibar")
cursor = db.cursor()
TIMEOUT = 10 # number of seconds the user has to give an Input

def interrupted(signum, frame):
    # if user has not made an Input a New user can connect 
    GPIO.output(12, GPIO.LOW)  #Gelbe LED
    GPIO.output(16, GPIO.LOW)  #Grüne LED
    GPIO.output(18, GPIO.HIGH) #Rote LED
    cprint('   Sorry, aber da war keine Eingabe ey!  ', 'white', 'on_red', attrs=['bold'])    
    time.sleep(4)
    GPIO.output(18, GPIO.LOW)
    signal.alarm()
    hello()
        
signal.signal(signal.SIGALRM, interrupted)
def input():
    try:
            GPIO.output(12, GPIO.HIGH)
            foo = raw_input()
            return foo
    except:
            GPIO.output(12, GPIO.LOW)
            hello()
            

def end_read(signal,frame):
    global continue_reading
    print "Ctrl+C gedrückt, Programm beendet."
    continue_reading = False
    GPIO.cleanup()
    sys.exit(0)
 
signal.signal(signal.SIGINT, end_read)
MIFAREReader = MFRC522.MFRC522()

def hello():
    GPIO.output(12, GPIO.LOW)
    GPIO.output(16, GPIO.LOW)
    GPIO.output(18, GPIO.LOW)
    os.system('cls' if os.name=='nt' else 'clear')
    cprint (41*'*','green', 'on_grey')
    print colored('*       Willkommen zur PiBar v3.0       *', 'green', 'on_grey')
    print colored('*       Präsentiert von Tom Erber       *', 'green', 'on_grey')
    print colored('*    Unterstützt durch Alkoholkonsum    *', 'green', 'on_grey')
    cprint (41*'*','green', 'on_grey')
    sql = ("SELECT COUNT(customerId) AS OrdersFromCustomerID FROM orders where isPaid=0")
    cursor.execute(sql)
    result = cursor.fetchall()
    cprint (41*'-','green', 'on_grey')
    cprint("    Bitte scanne deine Benutzer Karte!   ", 'white', 'on_green', attrs=['bold'])
    cprint (41*'-','green', 'on_grey')
    for data in result:
        txt = (" " +str(data[0])) 
        print colored('Anzahl aller getrunken Getränke: ' ,'white', 'on_grey' ), colored(txt, 'yellow', 'on_grey')
    sql =("SELECT CONCAT(c.firstName,' ', c.lastName ) AS 'Name', SUM( p.price ) AS 'Money' FROM customers c LEFT JOIN orders o ON o.customerId = c.id LEFT JOIN products p ON p.id = o.productId WHERE o.isPaid =0")
    cursor.execute(sql)
    result = cursor.fetchall()
    for data in result:
        print colored('Wert aller getrunken Getränke:','white', 'on_grey' ),colored(str(data[1])+' €', 'yellow', 'on_grey')     
    scan()
    
def scan():
    read = True
    while read:
        GPIO.output(16, GPIO.HIGH)
        (status,TagType) = MIFAREReader.MFRC522_Request(MIFAREReader.PICC_REQIDL)
        GPIO.output(16, GPIO.LOW)
        time.sleep(0.60)
        (status,uid) = MIFAREReader.MFRC522_Anticoll()
        if status == MIFAREReader.MI_OK:
            cardid = str(uid[0]) +str(uid[1]) +str(uid[2]) +str(uid[3]) #+str(uid[4])
            read = False
            if db.open:
                who_am_i(cardid)
            else:
                db.close
                cursor = db.cursor()
        GPIO.output(12, GPIO.LOW)
def admin():
    cprint ('             ADMIN MODUS!!!1!            ', 'red', 'on_white')
    read = True
    cardid = "NOPE"
    cprint ('   Scanne einen Benutzer zum Stornieren  ', 'white', 'on_red')
    while read:
        (status,TagType) = MIFAREReader.MFRC522_Request(MIFAREReader.PICC_REQIDL)
        GPIO.output(18, GPIO.HIGH)
        GPIO.output(12, GPIO.HIGH)
        GPIO.output(16, GPIO.HIGH)
        time.sleep(0.5)
        (status,uid) = MIFAREReader.MFRC522_Anticoll()
        GPIO.output(18, GPIO.LOW)
        GPIO.output(12, GPIO.LOW)
        GPIO.output(16, GPIO.LOW)
        if status == MIFAREReader.MI_OK:
            cardid = str(uid[0]) +str(uid[1]) +str(uid[2]) +str(uid[3]) #+str(uid[4])
            read = False
            cursor.execute("SELECT * FROM customers where tagid = " +cardid)
            if not cursor.rowcount:
                sql =("INSERT INTO customers (tagid, firstName, lastName, admin, userCard) VALUES(%s, %s, 'Blanko', 0, %s)")
                timer = time.strftime("%H:%M:%S")
                cursor.execute(sql, (cardid, timer, timer))
                db.commit() 
                GPIO.output(16, GPIO.HIGH)
                cprint('Neuen vorübergehenden Benutzer angelegt!', 'white', 'on_red', attrs=['bold'])
                time.sleep(2)
                GPIO.output(16, GPIO.LOW)
                db.close
                hello()
            else:
                result = cursor.fetchall()
                for data in result:
                    userid = data[0]
                    cursor.execute("DELETE FROM orders WHERE customerId="+str(userid)+" AND isPaid=0 ORDER BY orderDate DESC LIMIT 1")
                    cprint('       Letztes Produkt gelöscht!         ', 'white', 'on_red', attrs=['bold'])
                    db.commit()
                    GPIO.output(16, GPIO.HIGH)
                    time.sleep(2)
                    GPIO.output(16, GPIO.LOW)
                    db.close
                    hello() 
                                                              
def who_am_i(cardid):
    GPIO.output(15, GPIO.HIGH)
    time.sleep(0.1)
    GPIO.output(15, GPIO.LOW)
    cursor.execute("SELECT * FROM customers where tagid = " +cardid)
    if not cursor.rowcount:
            GPIO.output(18, GPIO.HIGH)
            cprint('  Sorry aber den Benutzer gibt es nicht! ', 'white', 'on_red', attrs=['bold'])
            print time.strftime("%H:%M:%S") 
            time.sleep(2)
            GPIO.output(18, GPIO.LOW)
            db.close
            hello()
    else:
        os.system('cls' if os.name=='nt' else 'clear')
        result = cursor.fetchall() 
        for data in result:
            userid = data[0]
            name = (str(data[2]) +" "+str(data[3]))
            if str(data[4]) == "1":
                admin()
            else:
                termios.tcflush(sys.stdin, termios.TCIOFLUSH)
                sql =("SELECT CONCAT_WS( '', c.firstName, c.lastName ) AS 'Name', SUM( p.price ) AS 'Offener Betrag' FROM customers c LEFT JOIN orders o ON o.customerId = c.id LEFT JOIN products p ON p.id = o.productId WHERE c.id = %s AND o.isPaid =0 GROUP BY c.id")
                cursor.execute(sql, (userid))
                result = cursor.fetchall()
                txt = "0.0 €"
                for data in result:
                    txt = (str(data[1]) +" €")
                #colored('Your account: ' ,'blue', 'on_white' ), colored(txt, 'white', 'on_red') 
                text= ("Hallo, " +name)
                while len(text)< 41:
                    text = text + " "
                cprint (text, 'blue', 'on_white')
                while len(txt)< 19:
                    txt = txt + " "
                print colored('Auf deiner Karte sind: ' ,'blue', 'on_white' ), colored(txt ,'white', 'on_red', attrs=['bold'])
                cprint (41*'-','green', 'on_grey')
                cprint('        Bitte scanne ein Produkt!        ', 'white', 'on_green', attrs=['bold'])
                cprint (41*'-','green', 'on_grey')
                signal.alarm(TIMEOUT)
                ean = input()
                signal.alarm(0)
                os.system('cls' if os.name=='nt' else 'clear')
                cursor.execute("SELECT * FROM products where ean = '" +ean+"'")
                if not cursor.rowcount:
                    GPIO.output(18, GPIO.HIGH)
                    cprint('Sorry aber das Produkt kenne ich nicht!', 'white', 'on_red', attrs=['bold'])
                    time.sleep(3)
                    db.close
                    hello()
                else:
                    result = cursor.fetchall() 
                    for data in result:
                        drinkid = data[0]
                    txt = (str(data[2]) +" ")
                    platzhalter = ""
                    txt2 = ("-> " +str(data[3])+" €")
                    while len(txt)+len(txt2)+len(platzhalter)< 42:
                            platzhalter = platzhalter + " "
                    print colored (txt+platzhalter, 'blue', 'on_white'), colored(txt2, 'red', 'on_white')           
                    sql =("INSERT INTO orders (customerId, productId) VALUES(%s, %s)")
                    cursor.execute(sql, (userid,drinkid))
                    db.commit()
                    sql =("SELECT CONCAT_WS( '', c.firstName, c.lastName ) AS 'Name', SUM( p.price ) AS 'Offener Betrag' FROM customers c LEFT JOIN orders o ON o.customerId = c.id LEFT JOIN products p ON p.id = o.productId WHERE c.id = %s AND o.isPaid =0 GROUP BY c.id")
                    cursor.execute(sql, (userid))
                    result = cursor.fetchall()
                    for data in result:
                        txt = (str(data[1]) +" €")
                        platzhalter =""
                        while len(txt)+len(platzhalter)< 21:
                            platzhalter = platzhalter + " "
                        print colored('Jetzt auf der Karte: '+ platzhalter ,'blue', 'on_white' ), colored(txt, 'white', 'on_red') 
                    sql = ("SELECT COUNT(customerId) AS OrdersFromCustomerID FROM orders WHERE customerId=%s")
                    cursor.execute(sql, (userid))
                    result = cursor.fetchall()
                    for data in result:
                        txt = (" " +str(data[0])) 
                        platzhalter = ""
                        while len(txt)+len(platzhalter)< 18:
                            platzhalter = platzhalter + " " 
                        print colored('Anzahl von Getränken: '+platzhalter ,'blue', 'on_white' ), colored(txt, 'yellow', 'on_white') 
                    
                    time.sleep(6.5)
                    db.close
                    hello()
    
hello()                                                   

Traceback (most recent call last):
  File "PiBar.py", line 236, in <module>
    hello()
  File "PiBar.py", line 87, in hello
    scan()
  File "PiBar.py", line 101, in scan
    who_am_i(cardid)
  File "PiBar.py", line 173, in who_am_i
    cursor.execute(sql, (userid))
  File "/usr/lib/python2.7/dist-packages/MySQLdb/cursors.py", line 207, in execute
    args = tuple(map(db.literal, args))
TypeError: argument 2 to map() must support iteration

#!/usr/bin/env python
# encoding: utf-8


"""
player.py


The audio player. A simple wrapper around the MPD client. Uses a lockable version
of the MPD client object, because we're using multiple threads
"""




__version_info__ = (0, 0, 1)
__version__ = '.'.join(map(str, __version_info__))
__author__ = "Willem van der Jagt"




from mpd import MPDClient
from threading import Lock
from book import Book
import config
import re




class LockableMPDClient(MPDClient):
    def __init__(self, use_unicode=False):
        super(LockableMPDClient, self).__init__()
        self.use_unicode = use_unicode
        self._lock = Lock()
    def acquire(self):
        self._lock.acquire()
    def release(self):
        self._lock.release()
    def __enter__(self):
        self.acquire()
    def __exit__(self, type, value, traceback):
        self.release() 




class Player(object):


    """The class responsible for playing the audio books"""


    def __init__(self, conn_details, status_light):
        """Setup a connection to MPD to be able to play audio.

        Also update the MPD database with any new MP3 files that may have been added
        and clear any existing playlists.
        """
        self.status_light = status_light
        self.book = Book()


        self.mpd_client = LockableMPDClient()
        with self.mpd_client:
            self.mpd_client.connect(**conn_details)


            self.mpd_client.update()
            self.mpd_client.clear()
            self.mpd_client.setvol(100)


    def get_mpd_playlist(self):
        # Return a list with radiostations
        # If song['name'] doesn't exist, copy song['url'] to it
        while True:
            try:
                playlist = self.mpd_client.playlistinfo()
                break
            except:
                print('Failed to get playlist from MPD')
                self.mpd_client.connect()


        for song in playlist:
            if 'name' not in song.keys():
                song['name'] = song['file']
        return playlist




    def get_current_songid(self):
        # returns current Playing/Paused song id
        try:
            cur = self.mpd_client.currentsong()
            return int(cur['id'])
        except:
            print('Failed to get current songid from MPD')
            return False




    def get_position_in_playlist(self, playlist, songid):
        # Return position in list (playlist) of songid or False if it isn't
        c = 0
        for song in playlist:
            if int(song['id']) != int(songid):
                c = c + 1
            else:
                return c
        return False


    def toggle_pause(self, channel):
        """Toggle playback status between play and pause"""

        with self.mpd_client:
            state = self.mpd_client.status()['state']
            if state == 'play':
                self.status_light.action = 'blink_pauze'
                self.mpd_client.pause()
            elif state == 'pause':
                self.status_light.action = 'blink'
                self.mpd_client.play()
            else:
                self.status_light.interrupt('blink_fast', 3)


    def rewind(self, channel):
        """Rewind by 20s"""


        self.status_light.interrupt('blink_fast', 3)

        if self.is_playing():
            song_index = int(self.book.part) - 1
            elapsed = int(self.book.elapsed)


            with self.mpd_client:


                if elapsed > 20:
                    # rewind withing current file if possible
                    self.mpd_client.seek(song_index, elapsed - 20)
                elif song_index > 0:
                    # rewind to previous file if we're not yet 20 seconds into
                    # the current file
                    prev_song = self.mpd_client.playlistinfo(song_index - 1)[0]
                    prev_song_len = int(prev_song['time'])


                    # if the previous part is longer than 20 seconds, rewind to 20
                    # seconds before the end, otherwise rewind to the start of it
                    if prev_song_len > 20:
                        self.mpd_client.seek(song_index - 1, prev_song_len - 20)
                    else:
                        self.mpd_client.seek(song_index - 1, 0)
                else:
                    # if we're less than 20 seconds into the first part, rewind
                    # to the start of it
                    self.mpd_client.seek(0, 0)


    def play_previous(self, channel):
        while True:
            try:
                self.mpd_client.previous()
                break
            except:
                print('Failed to switch to previous song')
                self.mpd_client.connect()




    def play_next(self, channel):
        # We have to check if we are not on the last track cause pressing
        # 'Next' would cause mpd to stop and we don't want that... right?
        playlist = self.get_mpd_playlist()
        last_pos = len(playlist) - 1
        cur_id = self.get_current_songid()
        cur_pos = self.get_position_in_playlist(playlist, cur_id)


        if cur_pos < last_pos:
            while True:
                try:
                    self.mpd_client.next()
                    break
                except:
                    print('Failed to switch to previous song')
                    self.mpd_client.connect()


    def volume_up(self, channel):
        volume = int(self.get_status()['volume'])
        self.set_volume(min(volume + 10, 100))




    def volume_down(self, channel):


        volume = int(self.get_status()['volume'])
        self.set_volume(max(volume - 10, 0))




    def set_volume(self, volume):
        """Set the volume on the MPD client"""
        self.status_light.interrupt('blink_fast', 3)
        with self.mpd_client:
            self.mpd_client.setvol(volume)
            print "volume set to %d" % volume




    def stop(self):
        """On stopping, reset the current playback and stop and clear the playlist

        In contract to pausing, stopping is actually meant to completely stop playing
        the current book and start listening to another"""


        self.playing = False
        self.book.reset()

        self.status_light.action = 'on'


        with self.mpd_client:
            self.mpd_client.stop()
            self.mpd_client.clear()




    def play(self, book_id, progress=None):
        """Play the book as defined in self.book

        1. Get the parts from the current book and add them to the playlsit
        2. Start playing the playlist
        3. Immediately set the position the last know position to resume playback where
           we last left off"""


        def sorter(file1, file2):


            """sorting algorithm for files in playlist"""
            pattern = '(\d+)(-(\d+))?\.mp3'

            try:
                file1_index = re.search(pattern, file1).groups()[2] or 0
                file2_index = re.search(pattern, file2).groups()[2] or 0


                return -1 if int(file1_index) < int(file2_index) else 1
            except:
                return 0




        with self.mpd_client:


            parts = self.mpd_client.search('filename', book_id)

            if not parts:
                self.status_light.interrupt('blink_fast', 3)
                return


            self.mpd_client.clear()

            for part in sorted(parts, cmp=sorter):
                self.mpd_client.add(part['file'])


            self.book.book_id = book_id

            if progress:
                # resume at last known position
                self.book.set_progress(progress)
                self.mpd_client.seek(int(self.book.part) - 1, int(self.book.elapsed))
            else:
                # start playing from the beginning
                self.mpd_client.play()

        self.status_light.action = 'blink'
        self.book.file_info = self.get_file_info()




    def is_playing(self):
        return self.get_status()['state'] == 'play'


    def finished_book(self):
        """return if a book has finished, in which case we need to delete it from the db
        or otherwise we could never listen to that particular book again"""

        status = self.get_status()
        return self.book.book_id is not None and \
               status['state'] == 'stop' and \
               self.book.part == int(status['playlistlength']) and \
               'time' in self.book.file_info and float(self.book.file_info['time']) - self.book.elapsed < 20






    def get_status(self):
        with self.mpd_client:
            return self.mpd_client.status()




    def get_file_info(self):
        with self.mpd_client:
            return self.mpd_client.currentsong()




    def close(self):
        self.stop()
        self.mpd_client.close()
        self.mpd_client.disconnect()

# import the serial library providing all
# functionality to interact with serial ports
import serial


# "/dev/ttyAMA0" is the name of the serial port
# on the Raspberry Pi the RFID reader from Seeedstudio
# sends serial data at a baudrate of 9600 a timeout of
# 1 second wil wait for data on the serial port for
# one second before continueing
port = serial.Serial("/dev/ttyAMA0", baudrate=9600, timeout=1)


while True:
    # the RFID reader sends the data for one tag as a 14 character string
    rcv = port.read(14)
    print rcv

import serial
import sys
import time
from operator import xor


# UART
ID = ""
Zeichen = 0


Checksumme = 0
Tag = 0 


# Flags
Startflag = "\x02"
Endflag = "\x03"


# UART oeffnen
UART = serial.Serial("/dev/ttyAMA0", 9600)
UART.open()


while True:


    # Variablen loeschen
    Checksumme = 0
    Checksumme_Tag = 0
    ID = ""

    # Zeichen einlesen
    Zeichen = UART.read() 


    # Uebertragungsstart signalisiert worden?
    if Zeichen == Startflag:


        # ID zusammen setzen 
        for Counter in range(13):

            Zeichen = UART.read() 
            ID = ID + str(Zeichen)

        # Endflag aus dem String loeschen
        ID = ID.replace(Endflag, "" );

        # Checksumme berechnen
        for I in range(0, 9, 2):
            Checksumme = Checksumme ^ (((int(ID[I], 16)) << 4) + int(ID[I+1], 16))
        Checksumme = hex(Checksumme)

        # Tag herausfiltern
        Tag = ((int(ID[1], 16)) << 8) + ((int(ID[2], 16)) << 4) + ((int(ID[3], 16)) << 0)
        Tag = hex(Tag)

        # Ausgabe der Daten
        print "------------------------------------------"
        print "Datensatz: ", ID
        print "Tag: ", Tag
        print "ID: ", ID[4:10]
        print "Checksumme: ", Checksumme
        print "------------------------------------------"