"nfcpy 1.0.4版本PDF文档：Python近场通信模块英文版"

版权申诉

143 浏览量更新于2024-02-27 收藏 594KB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

本文档是针对使用Python语言的nfcpy模块进行近场通信开发的“1.0.4”版本的官方文档。nfcpy模块是遵循NFC论坛规范，用于实现与NFC设备和标签进行无线短距离数据交换的Python模块。它旨在为集成NFC的应用程序提供一个易于使用但功能强大的框架。该模块的最新发布版本可以从PyPI安装，具体安装命令为.pip install -U nfcpy。本文档由Stephen Tiedemann于2022年3月10日发布，以下是主要内容： 1. 概述 1.1 要求 1.2 支持的设备 1.3 实现状态 1.4 参考资料 nfcpy模块是一个用Python编写的开源模块，用于在NFC（近场通信）应用程序中实现各种功能。本文档旨在为开发人员提供关于nfcpy模块的详尽信息，帮助他们快速上手并利用其强大的功能进行NFC开发。 1.1 要求本节介绍了nfcpy模块的系统要求和运行环境。具体包括Python版本、操作系统支持等内容。开发者在使用nfcpy模块进行开发时需要满足一定的系统要求，例如要求Python版本为3.6及以上，支持的操作系统包括Windows、Linux、macOS等。 1.2 支持的设备本节介绍了nfcpy模块所支持的NFC设备类型，包括读卡器、标签等。对于不同类型的设备，nfcpy模块提供了相应的API和功能接口，可以方便开发者进行开发和集成。 1.3 实现状态在本节中，作者介绍了nfcpy模块的实现状态，包括已实现的功能和待实现的功能。此外，还介绍了模块的稳定性和性能等方面的情况，帮助开发者了解模块的可靠性和适用性。 1.4 参考资料最后一节介绍了本文档中使用到的各种参考资料，包括官方文档、规范标准等。这些参考资料对于理解和使用nfcpy模块具有重要的指导意义，开发者可以通过这些资料更深入地了解模块的设计和实现原理。总的来说，本文档是一份非常详尽的nfcpy模块的官方文档，对于希望使用Python进行近场通信开发的开发者来说是一份非常有用的参考资料。通过阅读本文档，开发者可以快速了解nfcpy模块的特性和功能，掌握其基本的使用方法，并基于此进行自己的开发工作。同时，本文档也为开发者提供了丰富的参考资料，帮助他们更好地理解和使用nfcpy模块。

资源详情

资源推荐

nfcpy documentation, Release 1.0.4

2.4 Emulate a card

It is possible to emulate a card (NFC Tag) with nfcpy but unfortunately this only works with some NFC devices and is

limited to Type 3 Tag emulation. The RC-S380 fully supports Type 3 Tag emulation. Devices based on PN532, PN533,

or RC-S956 chipset can also be used but an internal frame size limit of 64 byte only allows read/write operations with

up to 3 data blocks.

Below is an example of an NDEF formatted Type 3 Tag. The ﬁrst 16 byte (ﬁrst data block) contain the attribute data

by which the reader will learn the NDEF version, the number of data blocks that can be read or written in a single

command, the total capacity and the write permission state. Bytes 11 to 13 contain the current NDEF message length,

initialized to zero. The example is made to speciﬁcally open only an RC-S380 contactless frontend (otherwise the

number of blocks that may be read or written should not be more than 3).

import nfc

import struct

ndef_data_area = bytearray(64

16)

ndef_data_area[0] = 0x10 # NDEF mapping version '1.0'

ndef_data_area[1] = 12 # Number of blocks that may be read at once

ndef_data_area[2] = 8 # Number of blocks that may be written at once

ndef_data_area[4] = 63 # Number of blocks available for NDEF data

ndef_data_area[10] = 1 # NDEF read and write operations are allowed

ndef_data_area[14:16] = struct.pack('>H', sum(ndef_data_area[0:14])) # Checksum

def ndef_read(block_number, rb, re):

if block_number < len(ndef_data_area) / 16:

first, last = block_number

16, (block_number+1)

block_data = ndef_data_area[first:last]

return block_data

def ndef_write(block_number, block_data, wb, we):

global ndef_data_area

if block_number < len(ndef_data_area) / 16:

first, last = block_number

16, (block_number+1)

ndef_data_area[first:last] = block_data

return True

def on_startup(target):

idm, pmm, sys = '03FEFFE011223344', '01E0000000FFFF00', '12FC'

target.sensf_res = bytearray.fromhex('01' + idm + pmm + sys)

target.brty = "212F"

return target

def on_connect(tag):

print("tag activated")

tag.add_service(0x0009, ndef_read, ndef_write)

tag.add_service(0x000B, ndef_read, lambda: False)

return True

with nfc.ContactlessFrontend('usb:054c:06c1') as clf:

while clf.connect(card={'on-startup': on_startup, 'on-connect': on_connect}):

print("tag released")

This is a fully functional NFC Forum Type 3 Tag. With a separate reader or Android apps such as NXP Tag Info and

NXP Tag Writer, NDEF data can now be written into the ndef_data_area and read back until the loop is terminated

with Control-C.

12 Chapter 2. Getting started

nfcpy documentation, Release 1.0.4

2.5 Work with a peer

The best part of NFC comes when the limitations of a single master controlling a humble servant are overcome. This

is achieved by the NFC Forum Logical Link Control Protocol (LLCP), which allows multiplexed communications

between two NFC Forum Devices with either peer able to send protocol data units at any time and no restriction to a

single application run in one direction.

An LLCP link between two NFC devices is requested with the llcp argument to clf.connect().

>>> import nfc

>>> clf = ContactlessFrontend('usb')

>>> clf.connect(llcp={}) # now touch a phone

True

When the ﬁrst example got LLCP running there is actually just symmetry packets exchanged back and forth until the

link is broken. We have to use callback functions to add some useful stuff.

>>> def on_connect(llc):

... print llc; return True

...

>>> clf.connect(llcp={'on-connect': connected})

LLC: Local(MIU=128, LTO=100ms) Remote(MIU=1024, LTO=500ms)

True

The on_connect function receives a single argument llc, which is the LogicalLinkController instance coor-

dinates aal data exchange with the remote peer. With this we can add client applications but they must be run in a

separate execution context to have on_connect return fast. Only after on_connect returns, the llc can start running the

symmetry loop (the LLCP heartbeat) with the remote peer and generally receive and dispatch protocol and service

data units.

When using the interactive interpreter it is less convinient to program in the callback functions so we will start a thread

in the callback to execute the llc.run* loop and return with False. This tells clf.connect() to return immediately

with the llc instance).

>>> import threading

>>> def on_connect(llc):

... threading.Thread(target=llc.run).start(); return False

...

>>> llc = clf.connect(llcp={'on-connect': on_connect})

>>> print llc

LLC: Local(MIU=128, LTO=100ms) Remote(MIU=1024, LTO=500ms)

Application code is not supposed to work directly with the llc object but use it to create Socket objects for the actual

communication. Two types of regular sockets can be created with either nfc.llcp.LOGICAL_DATA_LINK for

a connection-less socket or nfc.llcp.DATA_LINK_CONNECTION for a connection-mode socket. A connection-

less socket does not guarantee that application data is delivered to the remote application (although nfcpy makes sure

that it’s been delivered to the remote device). A connection-mode socket cares about reliability, unless the other

implementation is buggy data you send is guaranteed to make it to the receiving application - error-free and in order.

What can be done with an Android phone as the peer device is for example to send to its default SNEP Server. SNEP

is the NFC Forum Simple NDEF Exchange Protocol and a default SNEP Server is built into Android under the name

of Android Beam. SNEP messages are exchanged over an LLCP data link connection so we create a connection mode

socket, connect to the server with the service name known from the NFC Forum Assigned Numbers Register and then

send a SNEP PUT request with a web link to open.

2.5. Work with a peer 13

CHAPTER 3

Logical Link Control Protocol

The Logical Link Control Protocol allows multiplexed communications between two NFC Forum Peer Devices where

either peer can send protocol data units at any time (asynchronous balanced mode). The communication endpoints

are called Service Access Points (SAP) and are addressed by a 6 bit numerical identiﬁer. Protocol data units are

exchanged between exactly two service access points, from a source SAP (SSAP) to a destination SAP (DSAP). The

service access point address space is split into 3 parts: an address between 0 and 15 identiﬁes a well-known service,

an address between 16 and 31 identiﬁes a service that is registered in the local service environment, and addresses

between 32 and 63 are unregistered and normally used as a source address by client applications that send or connect

to peer services.

The interface to realize LLCP client and server applications in nfcpy is implemented by the nfc.llcp.Socket

class. A socket is created with a LogicalLinkController instance and the socket type as arguments to the

Socket constructor. The nfc.ContactlessFrontend.connect() method accepts callback functions that

will receive the active LogicalLinkController instance as argument.

import nfc

import nfc.llcp

def client(socket):

socket.sendto("message", addr=16)

def connected(llc):

socket = nfc.llcp.Socket(llc, nfc.llcp.LOGICAL_DATA_LINK)

Thread(target=client, args=(socket,)).start()

return True

clf = nfc.ContactlessFrontend()

clf.connect(llcp={'on-connect': connected})

Although service access points are generally identiﬁed by a numerical address, the LLCP service discovery component

allows SAPs to be associated with a globally unique service name and become discoverable by remote applications.

A service name may represent either an NFC Forum well-known or an externally deﬁned service name.

• The format urn:nfc:sn:<servicename> represents a well-known service name, for example the service

name urn:nfc:sn:snep identiﬁes the NFC Forum Simple NDEF Data Exchange (SNEP) default server.

nfcpy documentation, Release 1.0.4

• The format urn:nfc:xsn:<domain>:<servicename> represents a service name that is deﬁned by the

domain owner, for example the service name urn:nfc:xsn:nfc-forum.org:snep-validation is

the service name of a special SNEP server used by the NFC Forum during validation of the SNEP seciﬁcation.

In nfcpy a service name can be registered with Socket.bind() and a service name string as the address parameter.

The allocated service access point address number can then be retrived with getsockname(). A remote service

name can be resolved into a service access point address number with resolve().

def server(socket):

message, address = socket.recvfrom()

socket.sendto("It's me!", address)

def client(socket):

address = socket.resolve( 'urn:nfc:xsn:nfcpy.org:test-service' )

socket.sendto("Hi there!", address)

message, address = socket.recvfrom()

print("SAP {0} said: {1}".format(address, message))

def startup(llc):

socket = nfc.llcp.Socket(llc, nfc.llcp.LOGICAL_DATA_LINK)

socket.bind( 'urn:nfc:xsn:nfcpy.org:test-service' )

print("server bound to SAP {0}".format(socket.getsockname()))

Thread(target=server, args=(socket,)).start()

return llc

def connected(llc):

socket = nfc.llcp.Socket(llc, nfc.llcp.LOGICAL_DATA_LINK)

Thread(target=client, args=(socket,)).start()

return True

clf = nfc.ContactlessFrontend()

clf.connect(llcp={'on-startup': startup, 'on-connect': connected})

Connection-mode sockets must be connected before data can be exchanged. For a server socket this involves calls to

bind(), listen() and accept(), and for a client socket to call resolve() and connect() with the address

returned by resolve() or to simply call connect() with the service name as address (note that resolve()

becomes more efﬁcient when queries for multiple service names are needed).

def server(socket):

# note that this server only accepts one connection

# for multiple connections spawn a thread per accept

while True:

client = socket.accept()

while True:

message = client.recv()

print("Client said: {0}".format(message))

client.send("It's me!")

def client(socket):

socket.connect( 'urn:nfc:xsn:nfcpy.org:test-service' )

socket.send("Hi there!")

message = socket.recv()

print("Server said: {0}".format(message))

def startup(llc):

socket = nfc.llcp.Socket(llc, nfc.llcp.DATA_LINK_CONNECTION)

socket.bind( 'urn:nfc:xsn:nfcpy.org:test-service' )

print("server bound to SAP {0}".format(socket.getsockname()))

(continues on next page)

16 Chapter 3. Logical Link Control Protocol

剩余153页未读，继续阅读

快撑死的鱼

粉丝: 1w+
资源: 9151

"nfcpy 1.0.4版本PDF文档：Python近场通信模块英文版"

NFC_nfcpy用于近场通信的 Python 模块

近场通信技术及其应用.pdf

nfcpy:一个Python模块，用于读写NFC标签或与另一个NFC设备通信

请介绍一下近场通信技术

近场通信的matlab仿真

近场通信模型matlab

无线通信近场饱和是什么意思

iso14443协议中文pdf

eseHal_send

中级通信工程师 传输与接入(无线)pdf

esp32 adafruit_pn532

python sfm三维重建数据集

写一个非常规态基近场动力学计算复合裂纹的python代码

MFRC-522 IC卡感应模块

Android中的通信方式

gccphat近场和远场

Android 无线通信

近场doa估计 matlab

无线通信近场饱和的原因、处理方法

到底什么IEC 14443 A协议，它的由来是什么

最新资源

中级通信工程师传输与接入(无线)pdf