def main():
try:
clf_IN = nfc.ContactlessFrontend('usb:001:IN_PASORI')
clf_OUT = nfc.ContactlessFrontend('usb:001:OUT_PASORI')
GPIO.output(12, 1)
print GPIO.input(12)
thread_attend = threading.Thread(target=func_attend, args=(clf_IN, ))
thread_leave = threading.Thread(target=func_leave, args=(clf_OUT, ))
thread_attend.start()
thread_leave.start()
except IOError:
print 'deviceを認識できませんでした'
#警告音を鳴らす(一応)
buzzer()
GPIO.output(12, 0)
sys.exit(88)
except:
#log_fmt = '%(asctime)s- %(message)'
#logging.basicConfig(filename='attend_error.log',format=log_fmt)
#logging.exception(err)
traceback.print_exc()
pass
def ICReaderProc1():
clf = nfc.ContactlessFrontend('usb')
while True:
if (global_Flag.getFlag() == True):
# setメソッドが呼び出されるまでスレッドを待機させる
clf.close()
IcReaderThState.wait_flag = True
print("connect closed!")
IcReaderThState.event.wait()
IcReaderThState.wait_flag = False
clf = nfc.ContactlessFrontend('usb')
else:
# clf.sense( [リモートターゲット], [検索回数], [検索の間隔] )
target_res = clf.sense(target_req_felica,
iterations=1,
interval=TIME_interval)
if not target_res is None:
# 読み取りを行う（読み取り完了かタイムアップまでブロックされる）
tag = nfc.tag.activate(clf, target_res)
# 読み取り完了なら、タグ読み込みを行う
connected(tag)
# 次の読み込みまで、ブロッキングを行う
time.sleep(5)
clf.close()
print("connect closed!")
def run(self):
print("Starting NFC Worker")
while True:
try:
tag = self.reader.connect(
rdwr={'on-connect': lambda tag: False})
except OSError as e:
print("FAILED TO FIND THE READER", e)
time.sleep(5)
# Couldn't find serial connection. Try again in a bit!
self.reader.close()
self.reader = nfc.ContactlessFrontend()
self.reader.open('usb')
continue
try:
uid = tag.identifier
card_uid = ''
for part in uid:
card_uid += "%02X" % part
self.cardDetected.emit(card_uid)
except AttributeError: # can happen on a misread from pynfc
self.reader.close()
self.reader = nfc.ContactlessFrontend()
self.reader.open('usb')
finally:
time.sleep(1) # Only a single read per second
def write_record_wifi(self, reader="usb", data=[]):
"""Writes a wifi record in the NDEF format with a given reader
Args:
reader (str, optional): Name of the reader you want to use. Defaults to "usb".
data (list, optional): Data to record. Defaults to empty list.
"""
with nfc.ContactlessFrontend(reader) as clf:
target = clf.sense(RemoteTarget('106A'), RemoteTarget('106B'),
RemoteTarget('212F'))
if target is None:
print("Waiting for tag...")
while True:
target = clf.sense(RemoteTarget('106A'), RemoteTarget('106B'),
RemoteTarget('212F'))
if target is None:
sleep(0.1) # don't burn the CPU
continue
tag = nfc.tag.activate(clf, target)
print("Tag found, writting record...")
record = self.format_wifi_tag(data)
try:
tag.ndef.records = [record]
except:
print("Record not written")
break
print("Done")
break
def main():
clf = nfc.ContactlessFrontend('usb')
print "Touch a card"
clf.connect(rdwr={'on-connect': connected}) # now touch a tag
card_info = connected
clf.close()
def __init__(self):
clf = nfc.ContactlessFrontend('usb')
self.data = []
clf.connect(rdwr={'on-connect': self.__connected})
self.__calculate_payment()
self.data = self.data[1:]
self.data = self.data[::-1]
def main():
clf = nfc.ContactlessFrontend()
try:
while True:
print "Waiting for a tag or peer to be touched"
while True:
general_bytes = nfc.llcp.startup({})
tag = clf.poll(general_bytes)
if tag == None:
continue
if isinstance(tag, nfc.DEP):
wps_handover_init(tag)
break
if tag.ndef:
wps_tag_read(tag)
break
if tag:
print "Not an NDEF tag - remove tag"
while tag.is_present:
time.sleep(0.1)
break
except KeyboardInterrupt:
raise SystemExit
finally:
clf.close()
raise SystemExit
def check_NFC():
print('NFC and FeliCa waiting...')
# USBに接続されたNFCリーダに接続してインスタンス化
clf = nfc.ContactlessFrontend('usb')
mydict = {}
while True:
target_res = clf.sense(target_req_nfc,
target_req_felica,
iterations=int(TIME_cycle // TIME_interval) + 1,
interval=TIME_interval)
if not target_res is None:
tag = nfc.tag.activate(clf, target_res)
print('TAG type: ' + tag.type)
# FeliCaカードをタッチしたら読み込みをやめる
if tag.type == "Type3Tag":
break
# Type1,Type2:NFCタグ、Type4:Android端末でのNFCなど
else:
# NFCタグに埋めたtextを読む
records = tag.ndef.records
for record in records:
print('NFC detected. record.text = ' + record.text)
# str()で変換するとユニコードオブジェクトにならない
key = str(record.text)
mydict[key] = key
print('sleep ', str(TIME_wait), ' seconds')
time.sleep(TIME_wait)
for dic in mydict:
print(dic)
clf.close()
def main():
llcp_config = {'recv-miu': options.link_miu, 'send-lto': 1000}
if options.quirks == "android":
llcp_config['send-agf'] = False
for device in options.device:
try: clf = nfc.ContactlessFrontend(device); break
except LookupError: pass
else: return
try:
while True:
general_bytes = nfc.llcp.startup(llcp_config)
peer = llcp_connect(clf, general_bytes)
if peer is None: break
nfc.llcp.activate(peer)
try:
ndef_push_server = NdefPushServer()
ndef_push_server.start()
while nfc.llcp.connected() and not terminate.is_set():
terminate.wait(1)
except KeyboardInterrupt:
log.info("aborted by user")
break
finally:
nfc.llcp.shutdown()
log.info("I was the " + peer.role)
if options.loopmode is False:
break
finally:
clf.close()
def __init__(self, debug=False):
self._dbg = debug
self._log = get_logger(__class__.__name__, self._dbg)
self._log.debug('')
self.clf = nfc.ContactlessFrontend('usb')
self._log.debug('clf=%s', self.clf)
def __run(self):
try:
if self.__clf is not None:
return
# Port name: usb:072f:2200
self.__clf = nfc.ContactlessFrontend(self.port_name)
# Connect to the WFE.
self.__clf.connect(rdwr={
"on-startup": self.__on_startup,
"on-connect": self.__on_connected
})
if self.__clf is not None:
self.__clf.close()
del self.__clf
self.__clf = None
self._state.set_state(CardReaderState.START)
except Exception:
# When the horse when in to the river go to NONE state.
self._state.set_state(CardReaderState.STOP)
self.__logger.error(traceback.format_exc())
def nfc_imput():
global gpio_button
# USBに接続されたNFCリーダに接続してインスタンス化
clf = nfc.ContactlessFrontend('usb')
while True:
# Suica待ち受け開始
# clf.sense( [リモートターゲット], [検索回数], [検索の間隔] )
target_res = clf.sense(target_req_suica,
iterations=int(TIME_cycle // TIME_interval) + 1,
interval=TIME_interval)
if target_res is not None:
tag = nfc.tag.activate_tt3(clf, target_res)
tag.sys = 3
#IDmを取り出す
idm = binascii.hexlify(tag.idm)
break #NFC待ちループから抜ける
#スイッチが押されたら，
if GPIO.input(button_GPIO) == 0:
gpio_button = "0"
idm = "gpiobutton"
break
clf.close()
return idm
def auth():
path = f"{os.getcwd()}/allowCardLists.txt"
with open(path) as f:
cards = f.readlines()
cards = [i.replace('\n', '') for i in cards]
def connected(tag):
idm = binascii.hexlify(tag.idm).decode('utf-8')
for card in cards:
card.encode('utf-8')
if card == idm:
GPIO.setmode(GPIO.BCM)
gp_out = 4
GPIO.setup(gp_out, GPIO.OUT)
servo = GPIO.PWM(gp_out, 50)
servo.start(0)
servo.ChangeDutyCycle(10.5)
time.sleep(0.5)
servo.stop()
GPIO.cleanup()
return False
clf = nfc.ContactlessFrontend('usb')
clf.connect(rdwr={'on-connect': connected})
clf.close()
def main():
# get date & time
date = datetime.datetime.now().strftime("%Y/%m/%d")
time = datetime.datetime.now().strftime("%H:%M:%S")
# write the message to cvs file
fst_msg = "EEMS has been launched!"
with open('log_data.csv', 'a') as csvFile:
writer = csv.writer(csvFile)
writer.writerow([date, time, "null", fst_msg])
csvFile.close()
#wks = gc.open(sheet_name).worksheet('log_data')
wks = gc.open(sheet_name).worksheet('test_wks')
wks.append_row([date, time, "null", fst_msg])
systemRunPrint()
# start og while True
while True:
with nfc.ContactlessFrontend("usb") as clf:
rdwr = {
'targets': ['212F', '424F'], # Type3Tag
# 'on-startup': on_startup,
'on-connect': on_connect
}
clf.connect(rdwr=rdwr)
def run_once(self):
if self.options.device is None:
self.options.device = ['usb']
for device in self.options.device:
try:
clf = nfc.ContactlessFrontend(device)
except IOError:
pass
else:
break
else:
log.error("no contactless reader found")
raise SystemExit(1)
if "rdwr" in self.groups:
rdwr_options = {
'on-startup': self.on_rdwr_startup,
'on-connect': self.on_rdwr_connect,
}
else:
rdwr_options = None
if "llcp" in self.groups:
if self.options.mode is None:
self.options.role = None
elif self.options.mode in ('t', 'target'):
self.options.role = 'target'
elif self.options.mode in ('i', 'initiator'):
self.options.role = 'initiator'
llcp_options = {
'on-startup': self.on_llcp_startup,
'on-connect': self.on_llcp_connect,
'role': self.options.role,
'miu': self.options.miu,
'lto': self.options.lto,
'agf': not self.options.no_aggregation,
}
else:
llcp_options = None
if "card" in self.groups:
card_options = {
'on-startup': self.on_card_startup,
'on-connect': self.on_card_connect,
'on-release': self.on_card_release,
'targets': [],
}
else:
card_options = None
try:
kwargs = {
'llcp': llcp_options,
'rdwr': rdwr_options,
'card': card_options
}
return clf.connect(**kwargs)
finally:
clf.close()
def main():
clf = nfc.ContactlessFrontend()
print "Please touch a tag to send a hello to the world"
while True:
tag = clf.poll()
if tag and tag.ndef:
break
text_en = nfc.ndef.Text.TextRecord( ("en", "Hello World") )
text_de = nfc.ndef.Text.TextRecord( ("de", "Hallo Welt") )
text_fr = nfc.ndef.Text.TextRecord( ("fr", "Bonjour tout le monde") )
message = nfc.ndef.Message( [text_en, text_de, text_fr] )
tag.ndef.message = message.tostring()
print "Remove this tag"
while tag.is_present:
time.sleep(1)
print "Now touch it again to receive a hello from the world"
while True:
tag = clf.poll()
if tag and tag.ndef:
break
message = nfc.ndef.Message( tag.ndef.message )
for record in message:
if record.type == "urn:nfc:wkt:T":
text = nfc.ndef.Text.TextRecord( record )
print text.language + ": " + text.text
def check_FeliCa():
global color
print 'FeliCa waiting...'
# USBに接続されたNFCリーダに接続してインスタンス化
clf = nfc.ContactlessFrontend('usb')
# clf.sense( [リモートターゲット], [検索回数], [検索の間隔] )
target_res = clf.sense(target_req_felica,
iterations=int(TIME_cycle // TIME_interval) + 1,
interval=TIME_interval)
if not target_res is None:
tag = nfc.tag.activate(clf, target_res)
#IDmを取り出す
idm = binascii.hexlify(tag.idm)
print 'FeliCa detected. idm = ' + idm
if color == 'r':
operateKey(url, userAddress, carKey, 'UnlockCar')
sense.set_pixels(green_check)
color = 'g'
elif color == 'g':
operateKey(url, userAddress, carKey, 'LockCar')
sense.set_pixels(red_cross)
color = 'r'
#sleepなしでは次の読み込みが始まって終了する
print 'sleep ' + str(TIME_wait) + ' seconds'
time.sleep(TIME_wait)
clf.close()
def write_record(self, record_type, reader="usb", data="", append=False):
"""Writes a record in the NDEF format with a given reader
Args:
record_type ([type]): Type of record (text, uri or smartposter)
reader (str, optional): Name of the reader you want to use. Defaults to "usb".
data (str, optional): Data to record. Defaults to "".
append (bool, optional): Wether the data is appended or overwritten. Defaults to False.
"""
with nfc.ContactlessFrontend(reader) as clf:
target = clf.sense(RemoteTarget('106A'), RemoteTarget(
'106B'), RemoteTarget('212F'))
if target is None:
print("Waiting for tag...")
while True:
target = clf.sense(RemoteTarget('106A'), RemoteTarget(
'106B'), RemoteTarget('212F'))
if target is None:
sleep(0.1) # don't burn the CPU
continue
tag = nfc.tag.activate(clf, target)
print("Tag found, writting record...")
record = record_type(data)
if(append):
records = tag.ndef.records
print(records)
records.append(record)
tag.ndef.records = records
else:
tag.ndef.records = [record]
print("Done")
break
def __init__(self, **args):
super(Service, self).__init__()
args_mqtt = args.get('mqtt', dict())
args_nfc = args.get('nfc', dict())
assert args_nfc.get('encrypt_key') is not None, 'Config nfc.encrypt_key must be set'
self.mqtt_config = {
'server': args_mqtt.get('server', 'localhost'),
'port': args_mqtt.get('port', 1883),
'keepalive': args_mqtt.get('keepalive', 60),
'username': args_mqtt.get('username', None),
'password': args_mqtt.get('password', None),
'topic': args_mqtt.get('topic', 'nfc2mqtt')
}
self.nfc_config = {
'authenticate_password': args_nfc.get('authenticate_password', None),
'encrypt_key': args_nfc['encrypt_key'],
'id_length': args_nfc.get('id_length', 5),
'reader': args_nfc.get('reader', 'usb')
}
self.reader_reconnect_stat = dict()
self.nfc_cf = nfc.ContactlessFrontend(self.nfc_config['reader'])
self.write_tag_queue = list()
write_topic = '{}/write_tag'.format(self.mqtt_config['topic'])
wipe_topic = '{}/wipe_tag'.format(self.mqtt_config['topic'])
self.connect(subscribe_to=[write_topic, wipe_topic])
self.mqtt.message_callback_add(write_topic, self._on_write_tag_message)
self.mqtt.message_callback_add(wipe_topic, self._on_wipe_tag_message)
def __init__(self):
# Emulates RC-S380
self.nfcf_idm = bytearray.fromhex('011004107f12ce22')
self.nfcf_pmm = bytearray.fromhex('100b4b428485d0ff')
self.nfcf_sys = bytearray.fromhex('0003')
self.clf = nfc.ContactlessFrontend('udp')
self.thread = None
def run(self):
with nfc.ContactlessFrontend('usb') as clf:
while True:
if self.cancel_flag:
break
res = clf.sense(self.__TARGET_REQ_NFC,
self.__TARGET_REQ_FELICA,
iteration=1,
interval=self.__INTERVAL)
if not res is None:
tag = nfc.tag.activate(clf, res)
if tag.type == "Type3Tag":
idm, pmm = tag.polling(system_code=0xfe00)
tag.idm, tag.pmm, tag.sys = idm, pmm, 0xfe00
sc = nfc.tag.tt3.ServiceCode(
self.__TARGET_SERVICE_CODE >> 6,
self.__TARGET_SERVICE_CODE & 0x3f)
bc = nfc.tag.tt3.BlockCode(0)
data = tag.read_without_encryption([sc], [bc])
PayInfo.set_studentID(data[4:11].decode())
self.complete_flag = True
break
def run_once(self):
if self.options.device is None:
self.options.device = config.default_device
for device in self.options.device:
try:
clf = nfc.ContactlessFrontend(device)
except IOError:
pass
else:
break
else:
log.error('no nfc reader found')
raise SystemExit(1)
rdwr_options = {
'on-startup': self.on_rdwr_startup,
'on-connect': self.on_rdwr_connect,
}
try:
kwargs = {'rdwr': rdwr_options}
return clf.connect(**kwargs)
finally:
clf.close()
def main():
with nfc.ContactlessFrontend('usb:072f:2200') as clf:
while True:
target = clf.sense(RemoteTarget('106A'))
if target is None:
sleep(0.1) # don't burn the CPU
continue
serial = target.sdd_res.hex()
print("Found a target with serial " + serial + "!")
tag = nfc.tag.activate(clf, target)
if tag.ndef:
print("Tag is NDEF formatted!")
print("It has " + str(len(tag.ndef.records)) + " records.")
for record in tag.ndef.records:
print(" Record: " + record)
# To write a record to the tag, uncomment one of these lines:
# write_text(tag)
# write_wifi(tag)
# write_url(tag)
else:
print("Tag is not NDEF formatted.")
# We can still read and write raw memory on the chip.
# using `tag.read(page)` and `tag.write(page, data)`
print("Sleeping for 5 seconds before reading the next tag...")
sleep(5)
def main():
llcp_config = {'recv-miu': options.link_miu, 'send-lto': 500}
if options.quirks == "android":
llcp_config['send-agf'] = False
general_bytes = nfc.llcp.startup(llcp_config)
for device in options.device:
try: clf = nfc.ContactlessFrontend(device); break
except LookupError: pass
else: return
peer = None
try:
while True:
if options.mode == "target" or options.mode is None:
listen_time = 250 + ord(os.urandom(1))
peer = clf.listen(listen_time, general_bytes)
if isinstance(peer, nfc.DEP):
if peer.general_bytes.startswith("Ffm"):
break
if options.mode == "initiator" or options.mode is None:
peer = clf.poll(general_bytes)
if isinstance(peer, nfc.DEP):
if peer.general_bytes.startswith("Ffm"):
if options.quirks == "android":
# Google Nexus S does not receive the first
# packet if we send immediately.
time.sleep(0.1)
break
except KeyboardInterrupt:
log.info("aborted by user")
clf.close()
return
nfc.llcp.activate(peer)
time.sleep(0.5)
if not options.run_test:
log.info("no test specified")
test_suite = [test_01, test_02, test_03, test_04, test_05,
test_06, test_07, test_08, test_09, test_10,
test_11, test_12, test_13]
try:
for test in options.run_test:
if test > 0 and test <= len(test_suite):
try:
test_suite[test-1]()
log.info("PASS")
except TestError as error:
log.error("FAIL: {0}".format(error))
else: log.info("invalid test number '{0}'".format(test))
except KeyboardInterrupt:
log.info("aborted by user")
for thread in threading.enumerate():
log.info(thread.name)
finally:
nfc.llcp.shutdown()
clf.close()
log.info("I was the " + peer.role)
def main(args):
if args['--debug']:
loglevel = logging.DEBUG - (1 if args['--verbose'] else 0)
logging.getLogger("nfc.clf").setLevel(loglevel)
logging.getLogger().setLevel(loglevel)
try:
try:
waittime = float(args['--wait'])
except ValueError:
assert 0, "the '--wait T' argument must be a number"
assert waittime >= 0, "the '--wait T' argument must be positive"
try:
timeout = float(args['--time'])
except ValueError:
assert 0, "the '--time T' argument must be a number"
assert timeout >= 0, "the '--time T' argument must be positive"
except AssertionError as error:
print(str(error), file=sys.stderr)
return 2
try:
clf = nfc.ContactlessFrontend(args['--device'])
except IOError as error:
print("no device found on path %r" % args['--device'], file=sys.stderr)
return 3
try:
while True:
try:
target = None
if args['tt2']: target = listen_tta(timeout, clf, args)
if args['tt3']: target = listen_ttf(timeout, clf, args)
if args['tt4']: target = listen_tta(timeout, clf, args)
if args['dep']: target = listen_dep(timeout, clf, args)
if target:
print("{0} {1}".format(time.strftime("%X"), target))
except nfc.clf.CommunicationError as error:
if args['--verbose']: logging.error("%r", error)
except AssertionError as error:
print(str(error), file=sys.stderr)
return 2
if args['--repeat']: time.sleep(waittime)
else: return (0 if target else 1)
except nfc.clf.UnsupportedTargetError as error:
logging.error("%r", error)
return 2
except IOError as error:
if error.errno != errno.EIO: logging.error("%r", error)
else: logging.error("lost connection to local device")
return 3
except KeyboardInterrupt:
pass
finally:
clf.close()
def main():
clf = nfc.ContactlessFrontend()
try:
if len(sys.argv) > 1 and sys.argv[1] == "write-config":
wps_write_config_tag(clf)
raise SystemExit
if len(sys.argv) > 1 and sys.argv[1] == "write-password":
wps_write_password_tag(clf)
raise SystemExit
while True:
print "Waiting for a tag or peer to be touched"
tag = find_peer(clf)
if isinstance(tag, nfc.DEP):
wps_handover_init(tag)
continue
if tag.ndef:
wps_tag_read(tag)
continue
print "Not an NDEF tag - remove tag"
while tag.is_present:
time.sleep(0.1)
except KeyboardInterrupt:
raise SystemExit
finally:
clf.close()
raise SystemExit
def read():
with nfc.ContactlessFrontend('usb:072f:2200') as clf:
tag = clf.connect(rdwr=rdwr_options)
json = {
"rfid" : tag.identifier.encode('hex_codec'),
"ruangan_id": CLASS_ID
};
response = requests.post('http://127.0.0.1:8000/api/absen', json);
print(response.status_code)
if(response.status_code == 500):
for i in range(3):
nfc.clf.acr122.Device.turn_on_led_and_buzzer(clf.device)
time.sleep(0.2)
print(response.json().pesan)
elif(response.status_code == 404):
for i in range(4):
nfc.clf.acr122.Device.turn_on_led_and_buzzer(clf.device)
time.sleep(0.02)
elif(response.status_code == 200):
responseJSON = response.json()
if(responseJSON['status'] == False):
nfc.clf.acr122.Device.turn_on_led_and_buzzer(clf.device)
time.sleep(0.2)
nfc.clf.acr122.Device.turn_on_led_and_buzzer(clf.device)
print(responseJSON)
else:
nfc.clf.acr122.Device.turn_on_led_and_buzzer(clf.device)
time.sleep(1)
def main():
print("メインプログラム稼働")
#リーダーへの接続を試行
try:
#リーダーへの接続
clf = nfc.ContactlessFrontend("usb")
#接続エラー
except IOError:
print("リーダーが接続されていません")
#終了処理
go_to_exit()
print("リーダーの接続完了")
#リーダーでFelicaを読み取る設定
rdwr_options = {
'targets': ['212F', '424F'],
'on-connect': on_connect
}
#読み取りの試行
try:
print("読み取り開始")
clf.connect(rdwr=rdwr_options)
#キーボード入力で終了
except KeyboardInterrupt:
go_to_exit()
def main():
# initialize the NFC reader, if installed
clf = nfc.ContactlessFrontend()
while True:
# poll for a tag
tag = clf.poll()
if tag is None:
time.sleep(0.5)
continue
print "found", str(tag)
if isinstance(tag, nfc.Type3Tag):
if tag.ndef is None:
print "This tag is not NDEF compatible - try another one"
continue
print "NDEF container present"
print " version = %s" % tag.ndef.version
print " writeable = %s" % ("no", "yes")[tag.ndef.writeable]
print " capacity = %d byte" % tag.ndef.capacity
print " data size = %d byte" % len(tag.ndef.message)
print format_data(tag.ndef.message)
if not tag.ndef.writeable:
print "This tag is not writable - try another one"
continue
write_configuration(tag)
return
time.sleep(0.5)
def roop():
clf = nfc.ContactlessFrontend('usb')
global roop_flg
while roop_flg:
clf.connect(rdwr={'on-connect': connected})
clf.close()
