# -*- coding: latin-1 -*-
# -----------------------------------------------------------------------------
# Copyright 2011, 2017 Stephen Tiedemann <stephen.tiedemann@gmail.com>
#
# Licensed under the EUPL, Version 1.1 or - as soon they
# will be approved by the European Commission - subsequent
# versions of the EUPL (the "Licence");
# You may not use this work except in compliance with the
# Licence.
# You may obtain a copy of the Licence at:
#
# https://joinup.ec.europa.eu/software/page/eupl
#
# Unless required by applicable law or agreed to in
# writing, software distributed under the Licence is
# distributed on an "AS IS" basis,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
# express or implied.
# See the Licence for the specific language governing
# permissions and limitations under the Licence.
# -----------------------------------------------------------------------------
"""Device driver for the Arygon ACR122U contactless reader.
The Arygon ACR122U is a PC/SC compliant contactless reader that
connects via USB and uses the USB CCID profile. It is normally
intented to be used with a PC/SC stack but this driver interfaces
directly with the inbuilt PN532 chipset by tunneling commands through
the PC/SC Escape command. The driver is limited in functionality
because the embedded microprocessor (that implements the PC/SC stack)
also operates the PN532; it does not allow all commands to pass as
desired and reacts on chip responses with its own (legitimate)
interpretation of state.
========== ======= ============
function support remarks
========== ======= ============
sense_tta yes Type 1 (Topaz) Tags are not supported
sense_ttb yes ATTRIB by firmware voided with S(DESELECT)
sense_ttf yes
sense_dep yes
listen_tta no
listen_ttb no
listen_ttf no
listen_dep no
========== ======= ============
"""
import nfc.clf
from . import pn532
import os
import errno
import struct
from binascii import hexlify
import logging
log = logging.getLogger(__name__)
def init(transport):
device = Device(Chipset(transport))
device._vendor_name = transport.manufacturer_name
device._device_name = transport.product_name.split()[0]
return device
class Device(pn532.Device):
# Device driver class for the ACR122U.
def __init__(self, chipset):
super(Device, self).__init__(chipset, logger=log)
def sense_tta(self, target):
"""Activate the RF field and probe for a Type A Target at 106
kbps. Other bitrates are not supported. Type 1 Tags are not
supported because the device does not allow to send the
correct RID command (even though the PN532 does).
"""
return super(Device, self).sense_tta(target)
def sense_ttb(self, target):
"""Activate the RF field and probe for a Type B Target.
The RC-S956 can discover Type B Targets (Type 4B Tag) at 106
kbps. For a Type 4B Tag the firmware automatically sends an
ATTRIB command that configures the use of DID and 64 byte
maximum frame size. The driver reverts this configuration with
a DESELECT and WUPB command to return the target prepared for
activation (which nfcpy does in the tag activation code).
"""
return super(Device, self).sense_ttb(target)
def sense_ttf(self, target):
"""Activate the RF field and probe for a Type F Target. Bitrates 212
and 424 kpbs are supported.
"""
return super(Device, self).sense_ttf(target)
def sense_dep(self, target):
"""Search for a DEP Target. Both passive and passive communication
mode are supported.
"""
return super(Device, self).sense_dep(target)
def listen_tta(self, target, timeout):
"""Listen as Type A Target is not supported."""
info = "{device} does not support listen as Type A Target"
raise nfc.clf.UnsupportedTargetError(info.format(device=self))
def listen_ttb(self, target, timeout):
"""Listen as Type B Target is not supported."""
info = "{device} does not support listen as Type B Target"
raise nfc.clf.UnsupportedTargetError(info.format(device=self))
def listen_ttf(self, target, timeout):
"""Listen as Type F Target is not supported."""
info = "{device} does not support listen as Type F Target"
raise nfc.clf.UnsupportedTargetError(info.format(device=self))
def listen_dep(self, target, timeout):
"""Listen as DEP Target is not supported."""
info = "{device} does not support listen as DEP Target"
raise nfc.clf.UnsupportedTargetError(info.format(device=self))
def turn_on_led_and_buzzer(self):
"""Buzz and turn red."""
self.chipset.set_buzzer_and_led_to_active()
def turn_off_led_and_buzzer(self):
"""Back to green."""
self.chipset.set_buzzer_and_led_to_default()
class Chipset(pn532.Chipset):
# Maximum size of a host command frame to the contactless chip.
host_command_frame_max_size = 254
# Supported BrTy (baud rate / modulation type) values for the
# InListPassiveTarget command. Corresponds to 106 kbps Type A, 212
# kbps Type F, 424 kbps Type F, and 106 kbps Type B. The value for
# 106 kbps Innovision Jewel Tag (although supported by PN532) is
# removed because the RID command can not be send.
in_list_passive_target_brty_range = (0, 1, 2, 3)
def __init__(self, transport):
self.transport = transport
# read ACR122U firmware version string
reader_version = self.ccid_xfr_block(bytearray.fromhex("FF00480000"))
if not reader_version.startswith(b"ACR122U"):
log.error("failed to retrieve ACR122U version string")
raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
if int(chr(reader_version[7])) < 2:
log.error("{0} not supported, need 2.x".format(reader_version[7:]))
raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
log.debug("initialize " + reader_version.decode())
# set icc power on
log.debug("CCID ICC-POWER-ON")
frame = bytearray.fromhex("62000000000000000000")
transport.write(frame)
transport.read(100)
# disable autodetection
log.debug("Set PICC Operating Parameters")
self.ccid_xfr_block(bytearray.fromhex("FF00517F00"))
# switch red/green led off/on
log.debug("Configure Buzzer and LED")
self.set_buzzer_and_led_to_default()
super(Chipset, self).__init__(transport, logger=log)
def close(self):
self.ccid_xfr_block(bytearray.fromhex("FF00400C0400000000"))
self.transport.close()
self.transport = None
def set_buzzer_and_led_to_default(self):
"""Turn off buzzer and set LED to default (green only). """
self.ccid_xfr_block(bytearray.fromhex("FF00400E0400000000"))
def set_buzzer_and_led_to_active(self, duration_in_ms=300):
"""Turn on buzzer and set LED to red only. The timeout here must exceed
the total buzzer/flash duration defined in bytes 5-8. """
duration_in_tenths_of_second = int(min(duration_in_ms / 100, 255))
timeout_in_seconds = (duration_in_tenths_of_second + 1) / 10.0
data = "FF00400D04{:02X}000101".format(duration_in_tenths_of_second)
self.ccid_xfr_block(bytearray.fromhex(data),
timeout=timeout_in_seconds)
def send_ack(self):
# Send an ACK frame, usually to terminate most recent command.
self.ccid_xfr_block(Chipset.ACK)
def ccid_xfr_block(self, data, timeout=0.1):
"""Encapsulate host command *data* into an PC/SC Escape command to
send to the device and extract the chip response if received
within *timeout* seconds.
"""
frame = struct.pack("<BI5B", 0x6F, len(data), 0, 0, 0, 0, 0) + data
self.transport.write(bytearray(frame))
frame = self.transport.read(int(timeout * 1000))
if not frame or len(frame) < 10:
log.error("insufficient data for decoding ccid response")
raise IOError(errno.EIO, os.strerror(errno.EIO))
if frame[0] != 0x80:
log.error("expected a RDR_to_PC_DataBlock")
raise IOError(errno.EIO, os.strerror(errno.EIO))
if len(frame) != 10 + struct.unpack("<I", memoryview(frame)[1:5])[0]:
log.error("RDR_to_PC_DataBlock length mismatch")
raise IOError(errno.EIO, os.strerror(errno.EIO))
return frame[10:]
def command(self, cmd_code, cmd_data, timeout):
"""Send a host command and return the chip response.
"""
log.log(logging.DEBUG-1, "{} {}".format(self.CMD[cmd_code],
hexlify(cmd_data).decode()))
frame = bytearray([0xD4, cmd_code]) + bytearray(cmd_data)
frame = bytearray([0xFF, 0x00, 0x00, 0x00, len(frame)]) + frame
frame = self.ccid_xfr_block(frame, timeout)
if not frame or len(frame) < 4:
log.error("insufficient data for decoding chip response")
raise IOError(errno.EIO, os.strerror(errno.EIO))
if not (frame[0] == 0xD5 and frame[1] == cmd_code + 1):
log.error("received invalid chip response")
raise IOError(errno.EIO, os.strerror(errno.EIO))
if not (frame[-2] == 0x90 and frame[-1] == 0x00):
log.error("received pseudo apdu with error status")
raise IOError(errno.EIO, os.strerror(errno.EIO))
return frame[2:-2]
