def main():
        known_ids = {}
        cardtype = AnyCardType()
        #times out every 0.5 seconds
        cardrequest = CardRequest( timeout=0.5, cardType=cardtype )
        while True:
                try: 
                        # try to connect to a card, if the process 
                        # times out, continue
                        cardservice = cardrequest.waitforcard()
                        cardservice.connection.connect()
                        # compare ATRs
                        if ATR == cardservice.connection.getATR():
                                response, sw1, sw2 = \
                                    cardservice.connection.transmit( APDU )
                                tagid = toHexString(response).replace(' ','')
                                if tagid in known_ids:
                                        print "found uid"
                                        print tagid
                                else:
                                        known_ids[tagid] = True
                                        print "new uid"
                                        print tagid
                                # do appropriate things
                                post_to_server(tagid)
                                play_sound()
                except:
                        continue

    def __init__(self):

        cardtype = AnyCardType()
        self.resetCmd = [0x0, 0xA4, 0x4, 0x0, 0x8, 0xA0, 0x0, 0x0, 0x0, 0x54, 0x48, 0x0, 0x1]
        self.resetCmd1 = [0x0, 0xC0, 0x0, 0x0, 0xA]

        self.citizenCmd = [0x80, 0xB0, 0x0, 0x4, 0x2, 0x0, 0xD]
        self.citizenResponse = [0x0, 0xC0, 0x0, 0x0, 0xD]

        try:
            # request card insertion
            cardrequest = CardRequest(timeout=5, cardType=cardtype)
            self.cardservice = cardrequest.waitforcard()
            # attach the console tracer
            # observer = ConsoleCardConnectionObserver()
            # self.cardservice.connection.addObserver(observer)

            # connect to the card and perform a few transmits
            self.cardservice.connection.connect()
        except CardRequestTimeoutException:
            print 'time-out: no card inserted during last 5s'

        except:
            import sys
            print sys.exc_info()[1]

    def testcase_CardRequestNewCardInReaderNotPresentInfiniteTimeOut(self):
        """Test smartcard.CardRequest for any new card in a specific
        reader not present without time-out."""

        print 'please remove a smart card reader'
        _readerz = readers()
        while True:
            readerz = readers()
            if len(_readerz) > len(readerz):
                break
            time.sleep(.1)

        for reader in readerz:
            _readerz.remove(reader)

        cardtype = AnyCardType()
        cardrequest = CardRequest(
            timeout=None,
            readers=[_readerz[0]],
            cardType=cardtype,
            newcardonly=True)
        print 'Re-insert reader ', _readerz[0], 'with a card inside'
        cardservice = cardrequest.waitforcard()
        cardservice.connection.connect()
        print toHexString(
            cardservice.connection.getATR()), \
            'in', cardservice.connection.getReader()
        cardservice.connection.disconnect()

    def getATR(self):
        cardtype = AnyCardType()
        cardrequest = CardRequest(timeout=1, cardType=cardtype)
        cardservice = cardrequest.waitforcard()

        cardservice.connection.connect()
        return toHexString(cardservice.connection.getATR())

    def __init__(self, threadindex):
        '''Connect to a card with an ExclusiveTransmitCardConnection.'''
        threading.Thread.__init__(self)

        self.threadindex = threadindex

        # request any card type
        cardtype = AnyCardType()
        cardrequest = CardRequest(timeout=5, cardType=cardtype)
        cardservice = cardrequest.waitforcard()

        # attach our decorator
        cardservice.connection = ExclusiveTransmitCardConnection(cardservice.connection)

        # uncomment to attach the console tracer
        #observer=ConsoleCardConnectionObserver()
        #cardservice.connection.addObserver(observer)

        # connect to the card
        cardservice.connection.connect()

        self.cardservice = cardservice

        # this event will signal the end of the thread
        self.evtStop = threading.Event()

        # this timer will set the event stop event in 30s
        timer = threading.Timer(30, signalEvent, [self.evtStop])
        timer.start()
        self.countTransmitted = 0

    def getATR(self):
        cardtype = AnyCardType()
        cardrequest = CardRequest(timeout=1, cardType=cardtype)
        cardservice = cardrequest.waitforcard()

        cardservice.connection.connect()
        atr = toHexString(cardservice.connection.getATR())
        self.writeToLog("ATR: {0}".format(atr))

 def removeAllCards(self):
     print 'please remove all inserted smart cards'
     cardrequest = CardRequest()
     while True:
         cards = cardrequest.waitforcardevent()
         if 0 == len(cards):
             break
         time.sleep(.3)
     print 'ok'

	def __init__(self):
		cardtype = AnyCardType()
		cardrequest = CardRequest(timeout=10, cardType=cardtype)
		self.card = cardrequest.waitforcard()
		self.card.connection.connect()
		self.ins_db = []
		self.ins_db_update(INS_DB)
		self.log = []
	
		self.auto_get_response = True

 def __init__(self, add_a_byte, pinmin, pinmax, fixed):
     cardtype = AnyCardType()
     cardrequest = CardRequest(timeout=10, cardType=cardtype)
     cardservice = cardrequest.waitforcard()
     self.connection = cardservice.connection
     self.verify_ioctl = -1
     self.modify_ioctl = -1
     self.another_byte = add_a_byte
     self.pinmin = pinmin
     self.pinmax = pinmax
     self.fixed = fixed

    def testcase_CardRequestAnyCardTypeInSelectedReader(self):
        """Test smartcard.AnyCardType."""

        for reader in expectedReaders:
            atr = expectedATRinReader[reader]
            if [] != atr:
                ct = AnyCardType()
                cr = CardRequest(timeout=10.6, readers=[reader], cardType=ct)
                cs = cr.waitforcard()
                cs.connection.connect()
                self.assertEquals(atr, cs.connection.getATR())
                self.assertEquals(cs.connection.getReader(), expectedReaderForATR[toHexString(atr)])

    def testcase_CardRequestATRCardType(self):
        """Test smartcard.AnyCardType."""

        for atr in expectedATRs:
            if [] != atr:
                ct = ATRCardType(atr)
                cr = CardRequest(timeout=10, cardType=ct)
                cs = cr.waitforcard()
                cs.connection.connect()
                self.assertEquals(atr, cs.connection.getATR())
                self.assertEquals(cs.connection.getReader(), expectedReaderForATR[toHexString(atr)])
                cs.connection.disconnect()

def run():
    global cardservice
    try:
        cardtype = AnyCardType()
        cardreq = CardRequest(timeout=30,cardType=cardtype)
        cardservice = cardreq.waitforcard()
        cardservice.connection.setErrorCheckingChain(errorchain)
        cardservice.connection.connect()
        print "ATR = ", toHexString(cardservice.connection.getATR())
    except SWException, e:
        print str(e)
        return False

def receiveCard():
	cardtype = AnyCardType()
	cardrequest = CardRequest(timeout = 120, cardType = cardtype)
	
	while (1):
		try:
			cardservice = cardrequest.waitforcard()
			
		except CardRequestTimeoutException:
			continue
			
			
		return cardservice.connection

    def testcase_CardRequestAnyCardTypeAnyReaderPassThru(self):
        """Test smartcard.AnyCardType."""

        for reader in expectedReaders:
            atr = expectedATRinReader[reader]
            if [] != atr:
                ct = AnyCardType()
                cardservice = smartcard.PassThruCardService.PassThruCardService
                cr = CardRequest(timeout=10.6, readers=[reader], cardType=ct, cardServiceClass=cardservice)
                cs = cr.waitforcard()
                cs.connection.connect()
                self.assertEquals(cs.__class__, smartcard.PassThruCardService.PassThruCardService)
                self.assertEquals(atr, cs.connection.getATR())
                self.assertEquals(cs.connection.getReader(), expectedReaderForATR[toHexString(atr)])

def sc_connect():
	global cardservice	
	# detect the smart card based on the content of the ATR (card-centric approach)
	print('Initializing card connection...')
	try:
		cardtype = ATRCardType( toBytes( "3B 90 11 00" ) )
		cardrequest = CardRequest( timeout=5, cardType=cardtype )
		cardservice = cardrequest.waitforcard()
		print('Card connection established correctly')
	except:
		print('ERROR: Timeout exceeded')
		sys.exit(0)
	# connect to the card using T0 protocol.
	cardservice.connection.connect( CardConnection.T0_protocol )

    class __CardMonitoringThreadSingleton(Thread):
        """The real card monitoring thread class.

        A single instance of this class is created
        by the public CardMonitoringThread class.
        """

        def __init__(self, observable):
            Thread.__init__(self)
            self.observable = observable
            self.stopEvent = Event()
            self.stopEvent.clear()
            self.cards = []
            self.setDaemon(True)

        # the actual monitoring thread
        def run(self):
            """Runs until stopEvent is notified, and notify
            observers of all card insertion/removal.
            """
            self.cardrequest = CardRequest(timeout=0.1)
            while self.stopEvent.isSet() != 1:
                try:
                    currentcards = self.cardrequest.waitforcardevent()

                    addedcards = []
                    for card in currentcards:
                        if not self.cards.__contains__(card):
                            addedcards.append(card)

                    removedcards = []
                    for card in self.cards:
                        if not currentcards.__contains__(card):
                            removedcards.append(card)

                    if addedcards != [] or removedcards != []:
                        self.cards = currentcards
                        self.observable.setChanged()
                        self.observable.notifyObservers(
                            (addedcards, removedcards))

                # when CardMonitoringThread.__del__() is invoked in
                # response to shutdown, e.g., when execution of the
                # program is done, other globals referenced by the
                # __del__() method may already have been deleted.
                # this causes ReaderMonitoringThread.run() to except
                # with a TypeError or AttributeError
                except TypeError:
                    pass
                except AttributeError:
                    pass

                except:
                    # FIXME Tighten the exceptions caught by this block
                    traceback.print_exc()

        # stop the thread by signaling stopEvent
        def stop(self):
            self.stopEvent.set()

    def testcase_CardRequestNewCardAnyCardTypeInfiniteTimeOut(self):
        """Test smartcard.CardRequest for any new card without time-out."""

        self.removeAllCards()
        cardtype = AnyCardType()
        cardrequest = CardRequest(timeout=None, cardType=cardtype, newcardonly=True)
        print("re-insert any combination of cards six time")
        count = 0
        for i in range(0, 6):
            cardservice = cardrequest.waitforcard()
            try:
                cardservice.connection.connect()
                print(toHexString(cardservice.connection.getATR()), "in", cardservice.connection.getReader())
            except CardConnectionException:
                # card was removed too fast
                pass
            cardservice.connection.disconnect()
            count += 1
        self.assertEqual(6, count)

    def testcase_CardRequestNewCardAnyCardTypeFiniteTimeOutNoInsertion(self):
        """Test smartcard.CardRequest for new card with time-out and no
        insertion before time-out."""

        self.removeAllCards()

        # make sure we have 6 time-outs
        cardtype = AnyCardType()
        cardrequest = CardRequest(
            timeout=1, cardType=cardtype, newcardonly=True)
        count = 0
        for i in range(0, 6):
            try:
                before = time.time()
                cardservice = cardrequest.waitforcard()
            except CardRequestTimeoutException, e:
                elapsed = int(10 * (time.time() - before))
                print '.',
                self.assert_(elapsed >= 10 and elapsed <= 11.)
                count += 1

 def update(self, observable, actions):
     (addedcards, removedcards) = actions
     for card in addedcards:
         try:
             cardType =  ATRCardType( toBytes( "%s" %toHexString(card.atr) ))
             cardRequest = CardRequest(timeout = 1, cardType = cardType)
             cardService = cardRequest.waitforcard()
             cardService.connection.connect()
             SELECT = [0xFF, 0xCA, 0x00, 0x00, 0x00]
             apdu = SELECT
             #print ("sending"  + toHexString(apdu))
             response, sw1, sw2 = cardService.connection.transmit( apdu )
             #print ('response: ', response, ' status words: ', "%x %x" % (sw1, sw2))
             hexUID = self.getParseHexUID(response)
             #print (hexUID)
             self.process(hexUID)
             # id = tagid
             # print ("UID is",id)
         except Exception as e:
             print (e)

    def testcase_CardRequestNewCardAnyCardTypeFiniteTimeOutInsertion(self):
        """Test smartcard.CardRequest for new card with time-out and
        insertion before time-out."""

        self.removeAllCards()

        # make sure insertion is within 5s
        cardtype = AnyCardType()
        cardrequest = CardRequest(
            timeout=5, cardType=cardtype, newcardonly=True)
        count = 0
        for i in range(0, 6):
            try:
                print 're-insert any card within the next 5 seconds'
                before = time.time()
                cardservice = cardrequest.waitforcard()
                count += 1
                elapsed = int(10 * (time.time() - before))
                self.assert_(elapsed <= 55.)
            except CardRequestTimeoutException, e:
                print 'too slow... Test will show a failure'