API tools faq
paste
Advertisement
Guest User

brizzi relay buzzer

a guest
Jul 22nd, 2019
112
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 26.36 KB | None | 0 0
raw download clone embed print report
  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()
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!