SHARE
TWEET

brizzi relay buzzer

a guest Jul 22nd, 2019 59 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. import logging
  2. import binascii
  3. import time
  4. # from smartcard.System import readers
  5. from smartcard.CardConnectionObserver import ConsoleCardConnectionObserver
  6. from smartcard.CardConnection import CardConnection
  7. from smartcard.CardMonitoring import CardMonitor, CardObserver
  8. from smartcard.util import *
  9. # from smartcard.scard import *
  10.  
  11. # gpio
  12. import RPi.GPIO as GPIO
  13.  
  14. '''
  15. https://stackoverflow.com/questions/7621897/python-logging-module-globally
  16. '''
  17.  
  18.  
  19. def setup_custom_logger(name):
  20.     formatter = logging.Formatter(fmt='%(asctime)s - %(levelname)s - %(module)s - %(message)s')
  21.  
  22.     handler = logging.StreamHandler()
  23.     handler.setFormatter(formatter)
  24.  
  25.     logger = logging.getLogger(name)
  26.     logger.setLevel(logging.DEBUG)
  27.     logger.addHandler(handler)
  28.     return logger
  29.  
  30.  
  31. '''
  32. main logger
  33. '''
  34. LOGGER_MAIN = setup_custom_logger("brizzi_root")
  35. GPIO_CONTROL_MAIN = None
  36.  
  37.  
  38. class GPIOControl:
  39.     # pin definition
  40.     pin_buzzer = 21
  41.     pin_gate = 20
  42.  
  43.     def __init__(self):
  44.         try:
  45.             self.initialize = False
  46.  
  47.             GPIO.setwarnings(False)
  48.             GPIO.setmode(GPIO.BCM)
  49.  
  50.             # setup pin
  51.             GPIO.setup(self.pin_buzzer, GPIO.OUT)
  52.             GPIO.output(self.pin_buzzer, GPIO.LOW)
  53.             GPIO.setup(self.pin_gate, GPIO.OUT)
  54.             GPIO.output(self.pin_gate, GPIO.LOW)
  55.  
  56.             self.initialize = True
  57.         except Exception as err:
  58.             pass
  59.             self.initialize = False
  60.  
  61.     # cleanup gpio
  62.     def gpio_cleanup(self):
  63.         try:
  64.             GPIO.cleanup()
  65.         except:
  66.             pass
  67.  
  68.     # buzzer on off
  69.     def buzzer_on_off(self, isOn=False):
  70.         GPIO.output(self.pin_buzzer, isOn * GPIO.HIGH)
  71.  
  72.     # gate on off
  73.     def gate_on_off(self, isOn=False):
  74.         GPIO.output(self.pin_gate, isOn * GPIO.HIGH)
  75.  
  76.     def buzzer_beep(self, repeat_num=1, delay_ms=200):
  77.         for i in range(0, repeat_num):
  78.             self.buzzer_on_off()
  79.             time.sleep(delay_ms / 1000)
  80.             self.buzzer_on_off(True)
  81.             time.sleep(delay_ms / 1000)
  82.  
  83.     def gate_open(self, delay_close_ms=6000):
  84.         self.gate_open(True)
  85.         time.sleep(delay_close_ms / 1000)
  86.         self.gate_open()
  87.  
  88.     def gate_close(self):
  89.         self.gate_on_off()
  90.  
  91.  
  92. class BrizziProcessor:
  93.     '''
  94.    pdu
  95.    '''
  96.     SAMCARD_SELECT = "00A4040C09A00000000000000011"
  97.     SAMCARD_AUTH_KEY = "80B0000020{card_number:0<16.16}{card_uid:0<14.14}FF0000030080000000{key_card:0<16.16}"
  98.     SAMCARD_CREATE_HASH = "80B4000058{:0<16.16}{:0<14.14}FF0000030080000000{:0<16.16}{:0<32.32}{:0<20.20}{:0<12.12}{:0<12.12}{:0<12.12}{:0>12.12}{:0<4.4}FFFFFFFF"
  99.     PICC_SELECT_AID1 = "5A010000"
  100.     PICC_GET_CARD_NUMBER = "BD00000000170000"
  101.     PICC_GET_CARD_STATUS = "BD01000000200000"
  102.     PICC_SELECT_AID3 = "5A030000"
  103.     PICC_REQUEST_KEY_CARD = "0A00"
  104.     PICC_GET_CARD_UID = "FFCA000000"
  105.     PICC_CARD_AUTH = "AF{:0<32.32}"
  106.     PICC_GET_LAST_TRANSACTION_DATE = "BD03000000070000"
  107.     PICC_GET_BALANCE = "6C00"
  108.     PICC_DEBET_BALANCE = "DC00{:0<6.6}00"
  109.     PICC_COMMIT_TRANSACTION = "C7"
  110.     PICC_ABORT_TRANSACTION = "A7"
  111.     PDU_GET_MORE_DATA = "00C00000{:0>2X}"
  112.     PICC_WRITE_LOG = "3B01000000200000{:0<16.16}{:0<16.16}{:0<6.6}{:0<6.6}EB{:0<6.6}{:0<6.6}{:0<6.6}"
  113.     PICC_WRITE_LAST_TRANSACTION = "3D03000000070000{:0<6.6}{:0<8.8}"
  114.  
  115.     def __init__(self, logger=None, sam_connection=None, picc_connection=None, mid="1122334455667788",
  116.                  tid="aabbccddeeff0000", debug_mode=True):
  117.         try:
  118.             # get setting
  119.             self._logger = logger
  120.             self._mid = mid
  121.             self._tid = tid
  122.             self.initialize = False
  123.  
  124.             # check sam and picc connection object
  125.             if sam_connection is None or picc_connection is None:
  126.                 self._logger and self._logger.error("SAM and or PICC connection is unavailable")
  127.             else:
  128.                 # assign to sam and picc interface
  129.                 self._reader_picc_connection = picc_connection
  130.                 self._reader_sam_connection = sam_connection
  131.  
  132.                 # add observer
  133.                 if debug_mode:
  134.                     self._reader_observer = ConsoleCardConnectionObserver()
  135.                     self._reader_picc_connection.addObserver(self._reader_observer)
  136.                     self._reader_sam_connection.addObserver(self._reader_observer)
  137.  
  138.                 # connect to picc only to check the card present or not
  139.                 self.card_open_connection()
  140.                 self.sam_open_connection()
  141.  
  142.                 self._logger and self._logger.debug("Initializing picc and samcard reader OK")
  143.  
  144.                 self.initialize = True
  145.         except Exception as err:
  146.             pass
  147.             self._logger and self._logger.error(err)
  148.  
  149.     def __enter__(self):
  150.         return self
  151.  
  152.     def __exit__(self, exc_type, exc_val, exc_tb):
  153.         # self.close_all_connection()
  154.         return True
  155.  
  156.     def close_all_connection(self):
  157.         try:
  158.             try:
  159.                 self._reader_picc_connection.disconnect()
  160.             except:
  161.                 pass
  162.  
  163.             try:
  164.                 self._reader_sam_connection.disconnect()
  165.             except:
  166.                 pass
  167.         except Exception as err:
  168.             pass
  169.             self._logger and self._logger.error(err)
  170.  
  171.     def card_close_connection(self):
  172.         try:
  173.             self._reader_picc_connection.disconnect()
  174.         except Exception as err:
  175.             pass
  176.             self._logger and self._logger.error(err)
  177.  
  178.     def card_open_connection(self):
  179.         try:
  180.             self._reader_picc_connection.connect(CardConnection.T1_protocol)
  181.             return True
  182.         except Exception as err:
  183.             pass
  184.             self._logger and self._logger.error(err)
  185.             return False
  186.  
  187.     def sam_close_connection(self):
  188.         try:
  189.             self._reader_sam_connection.disconnect()
  190.         except Exception as err:
  191.             pass
  192.             self._logger and self._logger.error(err)
  193.  
  194.     def sam_open_connection(self):
  195.         try:
  196.             self._reader_sam_connection.connect()
  197.             return True
  198.         except Exception as err:
  199.             pass
  200.             self._logger and self._logger.error(err)
  201.             return False
  202.  
  203.     def send_apdu(self, apdu_text=None, to_sam=True):
  204.         try:
  205.             if to_sam:
  206.                 self._logger and self._logger.debug("Transmit to SAMCARD = {}".format(apdu_text))
  207.                 data, sw1, sw2 = self._reader_sam_connection.transmit(toBytes(apdu_text))
  208.             else:
  209.                 self._logger and self._logger.debug("Transmit to PICC = {}".format(apdu_text))
  210.                 data, sw1, sw2 = self._reader_picc_connection.transmit(toBytes(apdu_text))
  211.  
  212.             self._logger and self._logger.debug("[SW1SW2] : DATA = [%02X%02X] : %s" % (sw1, sw2, toHexString(data)))
  213.         except Exception as err:
  214.             pass
  215.             self._logger and self._logger.error(err)
  216.             data = sw1 = sw2 = None
  217.  
  218.         return data, sw1, sw2
  219.  
  220.     def sam_select(self):
  221.         try:
  222.             _, sw1, sw2 = self.send_apdu(self.SAMCARD_SELECT)
  223.             select_result = sw1 == 0x90 and sw2 == 0
  224.         except Exception as err:
  225.             pass
  226.             self._logger and self._logger.error(err)
  227.             select_result = False
  228.         return select_result
  229.  
  230.     def card_select_aid1(self):
  231.         try:
  232.             data, sw1, sw2 = self.send_apdu(self.PICC_SELECT_AID1, False)
  233.             select_result = sw1 == 0x90 and sw2 == 0 and data[0] == 0
  234.         except Exception as err:
  235.             pass
  236.             self._logger and self._logger.error(err)
  237.             select_result = False
  238.         return select_result
  239.  
  240.     def card_get_number(self):
  241.         try:
  242.             data, sw1, sw2 = self.send_apdu(self.PICC_GET_CARD_NUMBER, False)
  243.             return toHexString(data[4:12], PACK)
  244.         except Exception as err:
  245.             pass
  246.             self._logger and self._logger.error(err)
  247.             return None
  248.  
  249.     def card_get_status(self):
  250.         try:
  251.             data, sw1, sw2 = self.send_apdu(self.PICC_GET_CARD_STATUS, False)
  252.             return data[4:6] == [0x61, 0x61]
  253.         except Exception as err:
  254.             pass
  255.             self._logger and self._logger.error(err)
  256.             return False
  257.  
  258.     def card_select_aid3(self):
  259.         try:
  260.             data, sw1, sw2 = self.send_apdu(self.PICC_SELECT_AID3, False)
  261.             select_result = sw1 == 0x90 and sw2 == 0 and data[0] == 0
  262.         except Exception as err:
  263.             pass
  264.             self._logger and self._logger.error(err)
  265.             select_result = False
  266.  
  267.         return select_result
  268.  
  269.     def card_request_key_card(self):
  270.         try:
  271.             data, sw1, sw2 = self.send_apdu(self.PICC_REQUEST_KEY_CARD, False)
  272.             card_key = data[1:] + [sw1, sw2]
  273.             return toHexString(card_key, PACK)
  274.         except Exception as err:
  275.             pass
  276.             self._logger and self._logger.error(err)
  277.             return None
  278.  
  279.     def card_get_uid(self):
  280.         try:
  281.             data, sw1, sw2 = self.send_apdu(self.PICC_GET_CARD_UID, False)
  282.             return toHexString(data, PACK)
  283.         except Exception as err:
  284.             pass
  285.             self._logger and self._logger.error(err)
  286.             return None
  287.  
  288.     def pdu_get_more_data(self, data_len=0, to_sam=True):
  289.         try:
  290.             return self.send_apdu(self.PDU_GET_MORE_DATA.format(data_len), to_sam)
  291.         except Exception as err:
  292.             pass
  293.             self._logger and self._logger.error(err)
  294.             return None
  295.  
  296.     def sam_authenticate_key(self, card_number_in, card_uid_in, key_card_in):
  297.         try:
  298.             random_key = None
  299.             data, sw1, sw2 = self.send_apdu(
  300.                 self.SAMCARD_AUTH_KEY.format(card_number=card_number_in, card_uid=card_uid_in, key_card=key_card_in))
  301.             if sw1 == 0x61:
  302.                 data, sw1, sw2 = self.pdu_get_more_data(sw2)
  303.                 if sw1 == 0x90 and sw2 == 0x00:
  304.                     random_key = toHexString(data[-16:], PACK)
  305.             else:
  306.                 random_key = None
  307.         except Exception as err:
  308.             pass
  309.             self._logger and self._logger.error(err)
  310.             random_key = None
  311.  
  312.         return random_key
  313.  
  314.     def sam_create_hash(self, card_number_in, card_uid_in, card_random_number_in, debet_value, proc_code=808117,
  315.                         ref_number=36, batch_num=3):
  316.         try:
  317.             pdu_txt = self.SAMCARD_CREATE_HASH.format(card_number_in,
  318.                                                       card_uid_in,
  319.                                                       card_random_number_in,
  320.                                                       toHexString(toASCIIBytes(card_number_in), PACK),
  321.                                                       toHexString(
  322.                                                           toASCIIBytes("{:0<10}".format(int(float(debet_value) * 100))),
  323.                                                           PACK),
  324.                                                       toHexString(
  325.                                                           toASCIIBytes("{:0<12}".format(time.strftime("%d%m%y"))),
  326.                                                           PACK),
  327.                                                       toHexString(
  328.                                                           toASCIIBytes("{:0<12}".format(time.strftime("%H%M%I"))),
  329.                                                           PACK),
  330.                                                       toHexString(toASCIIBytes("{:0>6d}".format(proc_code)), PACK),
  331.                                                       toHexString(toASCIIBytes("{:0>6d}".format(ref_number)), PACK),
  332.                                                       toHexString(toASCIIBytes("{:0>2d}".format(batch_num)), PACK)
  333.                                                       )
  334.             # print(pdu_txt)
  335.  
  336.             data, sw1, sw2 = self.send_apdu(pdu_txt)
  337.             hash_value = None
  338.             if sw1 == 0x61:
  339.                 data, sw1, sw2 = self.pdu_get_more_data(sw2)
  340.                 if sw1 == 0x90 and sw2 == 0x00:
  341.                     hash_value = toHexString(data, PACK)
  342.             else:
  343.                 hash_value = None
  344.  
  345.         except Exception as err:
  346.             pass
  347.             self._logger and self._logger.error(err)
  348.             hash_value = None
  349.  
  350.         return hash_value
  351.  
  352.     def card_authenticate(self, random_key_in):
  353.         try:
  354.             card_random_number = None
  355.             data, sw1, sw2 = self.send_apdu(self.PICC_CARD_AUTH.format(random_key_in), False)
  356.             if data[0] == 0x00:
  357.                 card_random_number = toHexString(data[1:9] + [sw1, sw2], PACK)
  358.             else:
  359.                 card_random_number = None
  360.         except Exception as err:
  361.             pass
  362.             self._logger and self._logger.error(err)
  363.             card_random_number = None
  364.  
  365.         return card_random_number
  366.  
  367.     def card_get_last_transaction_date(self):
  368.         try:
  369.             last_trans_data = None, None
  370.             data, sw1, sw2 = self.send_apdu(self.PICC_GET_LAST_TRANSACTION_DATE, False)
  371.             if data[0] != 0x00:
  372.                 last_trans_data = None, None
  373.             else:
  374.                 last_trans_data = time.strptime("{:02X}{:02X}{:02X}".format(data[1], data[2], data[3]),
  375.                                                 "%y%m%d"), int.from_bytes(data[4:] + [sw1, sw2], 'big')
  376.  
  377.         except Exception as err:
  378.             pass
  379.             self._logger and self._logger.error(err)
  380.             last_trans_data = None, None
  381.  
  382.         return last_trans_data
  383.  
  384.     def card_get_balance(self):
  385.         try:
  386.             data, sw1, sw2 = self.send_apdu(self.PICC_GET_BALANCE, False)
  387.             balance = -2
  388.             if data[0] == 0x00:
  389.                 balance = int.from_bytes(data[1:] + [sw1, sw2], 'little')
  390.         except Exception as err:
  391.             pass
  392.             self._logger and self._logger.error(err)
  393.             balance = -1
  394.  
  395.         return balance
  396.  
  397.     def card_debet_balance(self, debet_value=0):
  398.         try:
  399.             data, sw1, sw2 = self.send_apdu(
  400.                 self.PICC_DEBET_BALANCE.format(binascii.hexlify((debet_value).to_bytes(3, 'little')).decode()), False)
  401.             debet_status = data[0] == 0x00 and sw1 == 0x90 and sw2 == 0x00
  402.         except Exception as err:
  403.             pass
  404.             self._logger and self._logger.error(err)
  405.             debet_status = False
  406.  
  407.         return debet_status
  408.  
  409.     def card_commit_transaction(self):
  410.         try:
  411.             data, sw1, sw2 = self.send_apdu(self.PICC_COMMIT_TRANSACTION, False)
  412.             commit_result = data[0] == 0x00 and sw1 == 0x90 and sw2 == 0x00
  413.         except Exception as err:
  414.             pass
  415.             self._logger and self._logger.error(err)
  416.             commit_result = False
  417.  
  418.         return commit_result
  419.  
  420.     def cardAbortTransaction(self):
  421.         try:
  422.             data, sw1, sw2 = self.send_apdu(self.PICC_ABORT_TRANSACTION, False)
  423.             abort_result = data[0] == 0x00 and sw1 == 0x90 and sw2 == 0x00
  424.         except Exception as err:
  425.             pass
  426.             self._logger and self._logger.error(err)
  427.             abort_result = False
  428.  
  429.         return abort_result
  430.  
  431.     def card_write_log(self, debet_value=0, balance_before=0, balance_after=0, mid=None, tid=None):
  432.         try:
  433.             pdu = self.PICC_WRITE_LOG.format(
  434.                 mid and mid or self._mid,
  435.                 tid and tid or self._tid,
  436.                 time.strftime("%y%m%d"),
  437.                 time.strftime("%H%M%I"),
  438.                 binascii.hexlify(debet_value.to_bytes(3, 'little')).decode(),
  439.                 binascii.hexlify(balance_before.to_bytes(3, 'little')).decode(),
  440.                 binascii.hexlify(balance_after.to_bytes(3, 'little')).decode()
  441.             )
  442.             # print(pdu)
  443.             data, sw1, sw2 = self.send_apdu(pdu, False)
  444.             result = data[0] == 0x00 and sw1 == 0x90 and sw2 == 0x00
  445.         except Exception as err:
  446.             pass
  447.             self._logger and self._logger.error(err)
  448.             result = False
  449.  
  450.         return result
  451.  
  452.     def card_write_last_transaction(self, last_trans_date, last_akum_debet, debet_value=0):
  453.         try:
  454.             akum_debet_total = debet_value
  455.             if last_trans_date.tm_mon == int(time.strftime("%m")):
  456.                 akum_debet_total += last_akum_debet
  457.             data, sw1, sw2 = self.send_apdu(self.PICC_WRITE_LAST_TRANSACTION.format(
  458.                 time.strftime("%y%m%d"),
  459.                 binascii.hexlify((akum_debet_total).to_bytes(4, 'big')).decode()
  460.             ), False)
  461.             result = data[0] == 0x00 and sw1 == 0x90 and sw2 == 0x00
  462.         except Exception as err:
  463.             pass
  464.             self._logger and self._logger.error(err)
  465.             result = False
  466.  
  467.         return result
  468.  
  469.     def transaction_debet_card(self, debet_amount=0, mid=None, tid=None, proc_code=808117, ref_number=1,
  470.                                batch_number=1):
  471.         global transaction_result
  472.         try:
  473.             transaction_result = {
  474.                 'status': False,
  475.                 'card_number': "",
  476.                 'transaction_date': "0000-00-00",
  477.                 'transaction_time': "00:00:00",
  478.                 'balance': 0,
  479.                 'amount': 0,
  480.                 'ref_number': 0,
  481.                 'batch_number': 0,
  482.                 'mid': '',
  483.                 'tid': '',
  484.                 'hash': '00000000'
  485.             }
  486.  
  487.             # step 1
  488.             transaction_result.update(
  489.                 {
  490.                     'transaction_date': time.strftime("%Y-%m-%d"),
  491.                     'transaction_time': time.strftime("%H:%M:%I"),
  492.                     'amount': debet_amount,
  493.                     'mid': mid and mid or self._mid,
  494.                     'tid': tid and tid or self._tid,
  495.                     'ref_number': ref_number,
  496.                     'batch_number': batch_number
  497.                 }
  498.             )
  499.  
  500.             # open connection
  501.             if self.card_open_connection():
  502.                 if self.sam_select():
  503.                     # step 2
  504.                     if self.card_select_aid1():
  505.                         # step 3
  506.                         card_number = self.card_get_number()
  507.                         transaction_result['card_number'] = card_number
  508.                         if card_number is not None:
  509.                             # step 4
  510.                             if self.card_get_status():
  511.                                 # step 5
  512.                                 if self.card_select_aid3():
  513.                                     # step 6
  514.                                     card_key = self.card_request_key_card()
  515.                                     if card_key is not None:
  516.                                         # step 7
  517.                                         card_uid = self.card_get_uid()
  518.                                         if card_uid is not None:
  519.  
  520.                                             # step 8
  521.                                             sam_random_key = self.sam_authenticate_key(card_number, card_uid, card_key)
  522.                                             if sam_random_key is not None:
  523.                                                 # step 9
  524.                                                 card_random_number = self.card_authenticate(sam_random_key)
  525.                                                 if card_random_number is not None:
  526.                                                     # step 10
  527.                                                     last_trans_date, last_trans_akum_debet = self.card_get_last_transaction_date()
  528.                                                     if last_trans_date is not None and last_trans_akum_debet is not None:
  529.                                                         # step 11
  530.                                                         card_balance = self.card_get_balance()
  531.                                                         transaction_result['balance'] = card_balance
  532.                                                         if card_balance >= 0:
  533.                                                             # step 12
  534.                                                             if self.card_debet_balance(debet_amount):
  535.                                                                 # step 13
  536.                                                                 sam_hash = self.sam_create_hash(card_number, card_uid,
  537.                                                                                                 card_random_number,
  538.                                                                                                 debet_amount, proc_code,
  539.                                                                                                 ref_number,
  540.                                                                                                 batch_number)
  541.                                                                 transaction_result['hash'] = sam_hash
  542.                                                                 if sam_hash is not None:
  543.                                                                     # step 14
  544.                                                                     if self.card_write_log(debet_amount, card_balance,
  545.                                                                                            card_balance - debet_amount,
  546.                                                                                            transaction_result['mid'],
  547.                                                                                            transaction_result['tid']):
  548.                                                                         # step 15
  549.                                                                         if self.card_write_last_transaction(
  550.                                                                                 last_trans_date, last_trans_akum_debet,
  551.                                                                                 debet_amount):
  552.                                                                             # step 16
  553.                                                                             if self.card_commit_transaction():
  554.                                                                                 transaction_result['status'] = True
  555.                                                                             else:
  556.                                                                                 self.cardAbortTransaction()
  557.                                                                         else:
  558.                                                                             self.cardAbortTransaction()
  559.                                                                     else:
  560.                                                                         self.cardAbortTransaction()
  561.                                                                 else:
  562.                                                                     self.cardAbortTransaction()
  563.                                                             else:
  564.                                                                 self.cardAbortTransaction()
  565.             # self.card_close_connection()
  566.         except Exception as err:
  567.             pass
  568.             self._logger and self._logger.error(err)
  569.             transaction_result['status'] = False
  570.             # self.card_close_connection()
  571.  
  572.         return transaction_result
  573.  
  574.  
  575. class BrizziCardObserver(CardObserver):
  576.     """Card observer for brizzi
  577.    """
  578.  
  579.     # sam card
  580.     sam_connection = None
  581.     sam_uid = "3B6800000073C84013009000"
  582.  
  583.     def update(self, observable, actions):
  584.         """
  585.        When card is insert or removed, it goes here
  586.        :param observable:
  587.        :param actions:
  588.        """
  589.         (addedcards, removedcards) = actions
  590.         '''
  591.        for card in addedcards:
  592.            print(card.createConnection().getReader())
  593.            print("+Inserted: ", toHexString(card.atr))
  594.        for card in removedcards:
  595.            print("-Removed: ", toHexString(card.atr))
  596.        '''
  597.  
  598.         # get sam connection
  599.         for card in addedcards:
  600.             atrx = toHexString(card.atr, PACK)
  601.             LOGGER_MAIN.debug(atrx)
  602.             if atrx == self.sam_uid:
  603.                 if self.sam_connection is None:
  604.                     self.sam_connection = card.createConnection()
  605.             else:
  606.                 picc_connection = card.createConnection()
  607.                 # picc_connection.connect()
  608.                 # data, sw1, sw2 = picc_connection.transmit(toBytes("FF00480000"))
  609.                 # data, sw1, sw2 = picc_connection.transmit(toBytes("E0000028010F"))
  610.                 # firmware = toBytes("E000002900")
  611.                 # retx = picc_connection.control(SCARD_CTL_CODE(3500), firmware)
  612.                 # LOGGER_MAIN.debug(retx)
  613.                 with BrizziProcessor(sam_connection=self.sam_connection, picc_connection=picc_connection,
  614.                                      debug_mode=False) as conn_obj:
  615.                     if conn_obj.initialize:
  616.                         resultx = conn_obj.transaction_debet_card(1)
  617.                         LOGGER_MAIN.debug(resultx)
  618.                         if resultx['status']:
  619.                             GPIO_CONTROL_MAIN.buzzer_beep(1)
  620.                             GPIO_CONTROL_MAIN.gate_open()
  621.                         else:
  622.                             GPIO_CONTROL_MAIN.buzzer_beep(3)
  623.                             GPIO_CONTROL_MAIN.gate_close()
  624.  
  625.  
  626. def main():
  627.     try:
  628.         # initial screen
  629.         LOGGER_MAIN.info("System ready....")
  630.  
  631.         global GPIO_CONTROL_MAIN
  632.         GPIO_CONTROL_MAIN = GPIOControl()
  633.  
  634.         # card monitor
  635.         cardmonitor = CardMonitor()
  636.         cardobserver = BrizziCardObserver()
  637.         cardmonitor.addObserver(cardobserver)
  638.  
  639.         # eternal loop
  640.         try:
  641.             while True:
  642.                 time.sleep(1)
  643.         except Exception as err:
  644.             pass
  645.  
  646.         # delete observer
  647.         cardmonitor.deleteObserver(cardobserver)
  648.  
  649.         import sys
  650.  
  651.         if 'win32' == sys.platform:
  652.             print('press Enter to continue')
  653.             sys.stdin.read(1)
  654.     except Exception as err:
  655.         pass
  656.  
  657.     GPIO_CONTROL_MAIN.gpio_cleanup()
  658.  
  659.  
  660. if __name__ == '__main__':
  661.     main()
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!
 
Top