tamashii-nfc 3.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8551114bb64654d4d9a8dc7a3c7b32a7cb5542c4
+  data.tar.gz: 0d39c47ea8c9fa93162492c5015b00ec05c09237
+SHA512:
+  metadata.gz: 179ee7cab286a63039e12565a80fc9d9dc36f76f7ccf2fcbf0f677c4706e646532af803c27314b378ec4c95c9739415204a5ede500573d2454558af04d0ea427
+  data.tar.gz: 838923205132b08841b5523d860f3984762ec46fe544ea9ec93c9f89a7442deb37fcdfabf38f6db5f707ccd2d77a6e7016186a7f94080043d4e0d4705d384bc8

data/.autotest

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/CHANGELOG.rdoc

@@ -0,0 +1,25 @@
+=== 2.1.0 / 2011-05-27
+
+* 1 Enhancement
+
+  * Moved to libnfc version 1.5.x
+
+=== 2.0.1 / 2009-09-19
+
+* 1 Bugfix
+
+  * Raising an exception when a reader cannot be found.
+
+=== 2.0.0 / 2009-08-07
+
+* 2 major enhancements
+
+  * Switched from FFI to a C backend
+  * Now depends on libnfc 1.2.x
+
+=== 1.0.0 / 2009-06-01
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,19 @@
+.autotest
+CHANGELOG.rdoc
+Manifest.txt
+README.rdoc
+Rakefile
+bin/nfc
+ext/nfc/context.c
+ext/nfc/extconf.rb
+ext/nfc/nfc.c
+ext/nfc/nfc.h
+ext/nfc/nfc_device.c
+ext/nfc/nfc_felica.c
+ext/nfc/nfc_iso14443a.c
+lib/nfc.rb
+lib/nfc/device.rb
+lib/nfc/felica.rb
+lib/nfc/iso14443a.rb
+test/test_context.rb
+test/test_device.rb

data/README.rdoc

@@ -0,0 +1,76 @@
+= NFC
+
+* http://seattlerb.rubyforge.org
+
+== DESCRIPTION:
+
+NFC is a ruby wrapper for the Near Field Communication library.  The Near
+Field Communication library works with many USB RFID readers, so this gem
+lets you read RFID tags.
+
+== FEATURES/PROBLEMS:
+
+* Only supports ISO1443A (MIFARE) tags right now.
+
+== SYNOPSIS:
+
+  require 'nfc'
+
+  # Create a new context
+  ctx = NFC::Context.new
+
+  # Open the first available USB device
+  dev = ctx.open nil
+
+  # Block until a tag is available, then print tag info
+  p dev.select
+
+  # You can even run in an infinite loop if you'd like to continually find
+  # tags:
+
+  loop do
+    p dev.select
+  end
+
+== REQUIREMENTS:
+
+* A USB RFID reader.  I'm using the touchatag[http://touchatag.com].
+* libnfc
+
+== INSTALL:
+
+First install libnfc[http://libnfc.org/].
+I installed libnfc via homebrew:
+
+  $ brew install libnfc
+
+The install the gem:
+
+  $ sudo gem install nfc
+
+NOTE!!!!  The nfc gem requires libnfc version 1.7.0 or greater!
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009-2013 Aaron Patterson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,29 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+gem 'rake-compiler', '>= 0.4.1'
+require "rake/extensiontask"
+
+Hoe.plugin :debugging
+Hoe.plugin :git
+Hoe.plugin :minitest
+
+HOE = Hoe.spec('tamashii-nfc') do
+  developer('Aaron Patterson', 'aaron@tenderlovemaking.com')
+  self.readme_file   = 'README.rdoc'
+  self.history_file  = 'CHANGELOG.rdoc'
+  self.extra_rdoc_files  = FileList['*.rdoc']
+  self.spec_extras = { :extensions => ["ext/nfc/extconf.rb"] }
+end
+
+RET = Rake::ExtensionTask.new("tamashii-nfc", HOE.spec) do |ext|
+  ext.lib_dir = File.join('lib', 'nfc')
+end
+
+task :kill do
+  pid = `sudo launchctl list | grep pcscd`[/^\d+/]
+  `sudo kill #{pid}` if pid
+end
+
+# vim: syntax=Ruby

data/bin/nfc

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'nfc'
+nfc = NFC.instance
+
+puts "Connected to NFC reader: #{nfc.device.name}"
+puts
+nfc.find do |tag|
+  p tag
+end

data/ext/nfc/context.c

@@ -0,0 +1,61 @@
+#include <nfc.h>
+
+static VALUE allocate(VALUE klass) {
+  nfc_context * context;
+  nfc_init(&context);
+  return Data_Wrap_Struct(klass, NULL, nfc_exit, context);
+}
+
+static VALUE open_dev(VALUE self, VALUE name)
+{
+  nfc_context * ctx;
+  nfc_device * dev;
+  VALUE device;
+
+  Data_Get_Struct(self, nfc_context, ctx);
+
+  if (NIL_P(name)) {
+    dev = nfc_open(ctx, NULL);
+  } else {
+    dev = nfc_open(ctx, StringValuePtr(name));
+  }
+
+  if (NULL == dev)
+    rb_raise(rb_eRuntimeError, "Unable to open the device");
+
+  if(nfc_initiator_init(dev) < 0)
+    rb_raise(rb_eRuntimeError, "Could not initialize device");
+
+  device = Data_Wrap_Struct(cNfcDevice, 0, nfc_close, dev);
+  rb_iv_set(device, "@context", self);
+  return device;
+}
+
+static VALUE devices(VALUE self, VALUE len)
+{
+  nfc_context *ctx;
+  nfc_connstring * strs;
+  size_t found, i;
+  VALUE devs;
+
+  Data_Get_Struct(self, nfc_context, ctx);
+
+  strs = malloc(sizeof(nfc_connstring) * len);
+
+  found = nfc_list_devices(ctx, strs, 10);
+  devs = rb_ary_new2(found);
+  for (i = 0; i < found; i++) {
+    rb_ary_push(devs, rb_str_new2(strs[i]));
+  }
+  free(strs);
+  return devs;
+}
+
+void init_context()
+{
+  VALUE cContext = rb_define_class_under(mNfc, "Context", rb_cObject);
+  rb_define_alloc_func(cContext, allocate);
+
+  rb_define_method(cContext, "devices", devices, 1);
+  rb_define_method(cContext, "open", open_dev, 1);
+}

data/ext/nfc/extconf.rb

@@ -0,0 +1,18 @@
+# :stopdoc:
+
+require 'mkmf'
+
+dir_config 'libnfc'
+pkg_config 'libnfc'
+
+unless find_header('nfc/nfc.h')
+  abort "libnfc is missing.  please install libnfc: http://libnfc.org/"
+end
+
+unless find_library('nfc', 'nfc_init')
+  abort "libnfc is missing.  please install libnfc: http://libnfc.org/"
+end
+
+create_makefile('nfc/nfc')
+
+# :startdoc:

data/ext/nfc/nfc.c

@@ -0,0 +1,13 @@
+#include <nfc.h>
+
+VALUE mNfc;
+
+void Init_nfc()
+{
+  mNfc = rb_define_module("NFC");
+
+  init_context();
+  init_device();
+  init_iso14443a();
+  init_felica();
+}

data/ext/nfc/nfc.h

@@ -0,0 +1,17 @@
+#ifndef NFC_H
+#define NFC_H
+
+#include <ruby.h>
+#include <nfc/nfc.h>
+
+extern VALUE mNfc;
+extern VALUE cNfcISO14443A;
+extern VALUE cNfcFelica;
+extern VALUE cNfcDevice;
+
+void init_context();
+void init_device();
+void init_iso14443a();
+void init_felica();
+
+#endif

data/ext/nfc/nfc_device.c

@@ -0,0 +1,203 @@
+#include <nfc.h>
+
+VALUE cNfcDevice;
+
+/*
+ * call-seq:
+ *  select_passive_target(tag)
+ *
+ * Select the +tag+ type from the device
+ */
+static VALUE select_passive_target(VALUE self, VALUE tag)
+{
+  nfc_device * dev;
+  nfc_modulation * mod;
+  nfc_target * ti;
+
+  Data_Get_Struct(self, nfc_device, dev);
+  Data_Get_Struct(tag, nfc_modulation, mod);
+
+  ti = (nfc_target *)xmalloc(sizeof(nfc_target));
+
+  if (nfc_initiator_select_passive_target(dev, *mod, NULL, 0, ti) ) {
+    switch(mod->nmt) {
+      case NMT_ISO14443A:
+        return Data_Wrap_Struct(cNfcISO14443A, 0, xfree, ti);
+        break;
+      case NMT_FELICA:
+        /* return Data_Wrap_Struct(cNfcFelica, 0, free, ti); */
+        return Qnil;
+        break;
+      default:
+        rb_raise(rb_eRuntimeError, "untested type: %d", mod->nmt);
+    } 
+  }else {
+	xfree(ti);
+  }
+
+  return Qfalse;
+}
+
+/*
+ * call-seq:
+ *  poll_target(tag, ms)
+ *
+ * Poll the +tag+ type from the device
+ */
+static VALUE poll_target(VALUE self, VALUE tag, VALUE poll_nr, VALUE ms)
+{
+  nfc_device * dev;
+  nfc_modulation * mod;
+  nfc_target * ti;
+  int code;
+	int ms_c, poll_nr_c;
+  Data_Get_Struct(self, nfc_device, dev);
+  Data_Get_Struct(tag, nfc_modulation, mod);
+
+	ms_c = FIX2INT(ms);
+	poll_nr_c = FIX2INT(poll_nr);
+	
+  ti = (nfc_target *)xmalloc(sizeof(nfc_target));
+
+  code = nfc_initiator_poll_target(dev, mod, 1, poll_nr_c, ms_c, ti);
+
+  if (code > 0) {
+    switch(mod->nmt) {
+      case NMT_ISO14443A:
+        return Data_Wrap_Struct(cNfcISO14443A, 0, xfree, ti);
+        break;
+      case NMT_FELICA:
+        return Data_Wrap_Struct(cNfcFelica, 0, xfree, ti);
+        break;
+      default:
+        rb_raise(rb_eRuntimeError, "untested type: %d", mod->nmt);
+    }
+  }else {
+	xfree(ti);
+  }
+
+  return INT2NUM(code);
+}
+
+/*
+ * call-seq:
+ *  name
+ *
+ * Get the name of the tag reader
+ */
+static VALUE name(VALUE self)
+{
+  nfc_device * dev;
+  Data_Get_Struct(self, nfc_device, dev);
+
+  return rb_str_new2(nfc_device_get_name(dev));
+}
+
+/*
+ * call-seq:
+ *  deselect
+ *
+ * Deselect the current tag
+ */
+static VALUE dev_deselect(VALUE self)
+{
+  nfc_device * dev;
+  Data_Get_Struct(self, nfc_device, dev);
+
+  nfc_initiator_deselect_target(dev);
+
+  return self;
+}
+
+static VALUE mod_initialize(VALUE self, VALUE type, VALUE baud)
+{
+  nfc_modulation * mod;
+
+  Data_Get_Struct(self, nfc_modulation, mod);
+  mod->nmt = NUM2INT(type);
+  mod->nbr = NUM2INT(baud);
+
+  return self;
+}
+
+static VALUE mod_alloc(VALUE klass)
+{
+  nfc_modulation * modulation;
+
+  modulation = xcalloc(1, sizeof(nfc_modulation));
+
+  return Data_Wrap_Struct(klass, NULL, xfree, modulation);
+}
+
+static VALUE mod_nmt(VALUE self)
+{
+  nfc_modulation * mod;
+
+  Data_Get_Struct(self, nfc_modulation, mod);
+
+  return INT2NUM(mod->nmt);
+}
+
+static VALUE mod_nbr(VALUE self)
+{
+  nfc_modulation * mod;
+
+  Data_Get_Struct(self, nfc_modulation, mod);
+
+  return INT2NUM(mod->nbr);
+}
+
+static VALUE initiator_init(VALUE self)
+{
+  nfc_device * dev;
+  int err;
+
+  Data_Get_Struct(self, nfc_device, dev);
+
+  err = nfc_initiator_init(dev);
+  if (0 == err)
+    return Qtrue;
+
+  return INT2NUM(err);
+}
+
+static VALUE close_dev(VALUE self)
+{
+  nfc_device * dev;
+  int err;
+
+  Data_Get_Struct(self, nfc_device, dev);
+  nfc_close(dev);
+  DATA_PTR(self) = 0;
+
+  return Qnil;
+}
+
+void init_device()
+{
+  VALUE cNfcModulation;
+  cNfcDevice = rb_define_class_under(mNfc, "Device", rb_cObject);
+  rb_define_method(cNfcDevice, "initiator_init", initiator_init, 0);
+  rb_define_method(cNfcDevice, "select_passive_target", select_passive_target, 1);
+  rb_define_method(cNfcDevice, "poll_target", poll_target, 3);
+  rb_define_method(cNfcDevice, "name", name, 0);
+  rb_define_method(cNfcDevice, "deselect", dev_deselect, 0);
+  rb_define_method(cNfcDevice, "close", close_dev ,0);
+
+  cNfcModulation = rb_define_class_under(cNfcDevice, "Modulation", rb_cObject);
+
+  /* modulation types. */
+  rb_define_const(cNfcModulation, "NMT_ISO14443A", INT2NUM(NMT_ISO14443A));
+  rb_define_const(cNfcModulation, "NMT_FELICA", INT2NUM(NMT_FELICA));
+
+  /* baud rates */
+  rb_define_const(cNfcModulation, "NBR_UNDEFINED", INT2NUM(NBR_UNDEFINED));
+  rb_define_const(cNfcModulation, "NBR_106", INT2NUM(NBR_106));
+  rb_define_const(cNfcModulation, "NBR_212", INT2NUM(NBR_212));
+
+  rb_define_alloc_func(cNfcModulation, mod_alloc);
+
+  rb_define_method(cNfcModulation, "initialize", mod_initialize, 2);
+  rb_define_method(cNfcModulation, "nmt", mod_nmt, 0);
+  rb_define_method(cNfcModulation, "nbr", mod_nbr, 0);
+}

data/ext/nfc/nfc_felica.c

@@ -0,0 +1,62 @@
+#include <nfc.h>
+
+VALUE cNfcFelica;
+
+/*
+ * size_t szLen;
+ * byte_t btResCode;
+ * byte_t abtId[8];
+ * byte_t abtPad[8];
+ * byte_t abtSysCode[2];
+ */
+
+static VALUE szLen(VALUE self)
+{
+  nfc_felica_info * tag;
+  Data_Get_Struct(self, nfc_felica_info, tag);
+
+  return INT2NUM(tag->szLen);
+}
+
+static VALUE btResCode(VALUE self)
+{
+  nfc_felica_info * tag;
+  Data_Get_Struct(self, nfc_felica_info, tag);
+
+  return INT2NUM(tag->btResCode);
+}
+
+static VALUE abtId(VALUE self)
+{
+  nfc_felica_info * tag;
+  Data_Get_Struct(self, nfc_felica_info, tag);
+
+  return rb_str_new(tag->abtId, 8 );
+}
+
+static VALUE abtPad(VALUE self)
+{
+  nfc_felica_info * tag;
+  Data_Get_Struct(self, nfc_felica_info, tag);
+
+  return rb_str_new(tag->abtPad, 8 );
+}
+
+static VALUE abtSysCode(VALUE self)
+{
+  nfc_felica_info * tag;
+  Data_Get_Struct(self, nfc_felica_info, tag);
+
+  return rb_str_new(tag->abtSysCode, 2 );
+}
+
+void init_felica()
+{
+  cNfcFelica = rb_define_class_under(mNfc, "Felica", rb_cObject);
+
+  rb_define_method(cNfcFelica, "szLen", szLen, 0);
+  rb_define_method(cNfcFelica, "btResCode", btResCode, 0);
+  rb_define_method(cNfcFelica, "abtId", abtId, 0);
+  rb_define_private_method(cNfcFelica, "abtPad", abtPad, 0);
+  rb_define_private_method(cNfcFelica, "abtSysCode", abtSysCode, 0);
+}

data/ext/nfc/nfc_iso14443a.c

@@ -0,0 +1,100 @@
+#include <nfc.h>
+
+VALUE cNfcISO14443A;
+
+/*
+ * call-seq:
+ *  szUidLen
+ *
+ * Get the szUidLen
+ */
+static VALUE szUidLen(VALUE self)
+{
+  nfc_target * tag;
+  Data_Get_Struct(self, nfc_target, tag);
+
+  return INT2NUM(tag->nti.nai.szUidLen);
+}
+
+/*
+ * call-seq:
+ *  szAtsLen
+ *
+ * Get the szAtsLen
+ */
+static VALUE szAtsLen(VALUE self)
+{
+  nfc_target * tag;
+  Data_Get_Struct(self, nfc_target, tag);
+
+  return INT2NUM(tag->nti.nai.szAtsLen);
+}
+
+/*
+ * call-seq:
+ *  abtUid
+ *
+ * Get the abtUid
+ */
+static VALUE abtUid(VALUE self)
+{
+  nfc_target * tag;
+  Data_Get_Struct(self, nfc_target, tag);
+
+  return rb_str_new((const char *)tag->nti.nai.abtUid, tag->nti.nai.szUidLen);
+}
+
+/*
+ * call-seq:
+ *  abtAts
+ *
+ * Get the abtAts
+ */
+static VALUE abtAts(VALUE self)
+{
+  nfc_target * tag;
+  Data_Get_Struct(self, nfc_target, tag);
+
+  return rb_str_new((const char *)tag->nti.nai.abtAts, tag->nti.nai.szAtsLen);
+}
+
+/*
+ * call-seq:
+ *  abtAtqa
+ *
+ * Get the abtAtqa
+ */
+static VALUE abtAtqa(VALUE self)
+{
+  nfc_target * tag;
+  Data_Get_Struct(self, nfc_target, tag);
+
+  return rb_str_new((const char *)tag->nti.nai.abtAtqa, 2);
+}
+
+/*
+ * call-seq:
+ *  btSak
+ *
+ * Get the btSak
+ */
+static VALUE btSak(VALUE self)
+{
+  nfc_target * tag;
+  Data_Get_Struct(self, nfc_target, tag);
+
+  return INT2NUM(tag->nti.nai.btSak);
+}
+
+void init_iso14443a()
+{
+  cNfcISO14443A = rb_define_class_under(mNfc, "ISO14443A", rb_cObject);
+
+  rb_define_method(cNfcISO14443A, "szUidLen", szUidLen, 0);
+  rb_define_method(cNfcISO14443A, "szAtsLen", szAtsLen, 0);
+  rb_define_method(cNfcISO14443A, "btSak", btSak, 0);
+
+  rb_define_private_method(cNfcISO14443A, "abtUid", abtUid, 0);
+  rb_define_private_method(cNfcISO14443A, "abtAts", abtAts, 0);
+  rb_define_private_method(cNfcISO14443A, "abtAtqa", abtAtqa, 0);
+}

data/lib/nfc.rb

@@ -0,0 +1,12 @@
+require 'thread'
+require 'nfc/nfc'
+require 'nfc/device'
+require 'nfc/iso14443a'
+require 'nfc/felica'
+
+###
+# NFC is a class for dealing with Near Field Communication systems.  This
+# library will read RFID tags from an RFID reader.
+module NFC
+  VERSION = '3.1.2'
+end

data/lib/nfc/device.rb

@@ -0,0 +1,23 @@
+module NFC
+  class Device
+    DCO_HANDLE_CRC            = 0x00
+    DCO_HANDLE_PARITY         = 0x01
+    DCO_ACTIVATE_FIELD        = 0x10
+    DCO_INFINITE_LIST_PASSIVE = 0x20
+
+    IM_ISO14443A_106 = Modulation.new Modulation::NMT_ISO14443A,
+                                      Modulation::NBR_106
+    IM_FELICA = Modulation.new Modulation::NMT_FELICA,
+                               Modulation::NBR_212
+
+    # Find a tag, blocks until there is a tag available
+    def select type = :mfrc
+      select_passive_target NFC::Device::IM_ISO14443A_106 if type == :mfrc
+      select_passive_target NFC::Device::IM_FELICA if type == :felica
+    end
+    def poll type = :mfrc, poll_nr = 1, ms = 1
+      poll_target NFC::Device::IM_ISO14443A_106, poll_nr,ms if type == :mfrc
+      poll_target NFC::Device::IM_FELICA, poll_nr,ms if type == :felica
+    end
+  end
+end

data/lib/nfc/felica.rb

@@ -0,0 +1,34 @@
+module NFC
+  class Felica
+
+    def uid
+      abtId.unpack 'C*'
+    end
+
+    def pad
+      abtPad.unpack 'C*'
+    end
+
+    def sys_code
+      abtSysCode.unpack 'C*'
+    end
+
+    def to_s join_string = ''
+      sprintf((['%02x'] * 8 ).join(join_string), * uid).upcase
+    end
+
+    def inspect
+# 78     printf("The following (NFC) Felica tag was found:\n\n");
+# 79     printf("%18s","ID (NFCID2): "); print_hex(ti.tif.abtId,8);
+# 80     printf("%18s","Parameter (PAD): "); print_hex(ti.tif.abtPad,8);
+      pad = sprintf( (['%02x'] * 8 ).join('  '), *self.pad) 
+      string_ary = [
+        "(NFC) Felica Tag",
+        "ID    (NFCID2): #{to_s '  '}",
+        "Parameter(PAD): #{pad}"
+      ]
+      string_ary.join "\n"
+    end
+
+  end
+end

data/lib/nfc/iso14443a.rb

@@ -0,0 +1,43 @@
+module NFC
+  class ISO14443A
+    ###
+    # Get the unique ID for this tag
+    def uid
+      abtUid.unpack 'C*'
+    end
+
+    ###
+    # Get the ATS for this tag
+    def ats
+      abtAts.unpack 'C*'
+    end
+
+    ###
+    # Get the atqa
+    def atqa
+      abtAtqa.unpack 'C*'
+    end
+
+    ###
+    # Get the UID as a hex string
+    def to_s join_string = ''
+      sprintf((['%02x'] * szUidLen).join(join_string), * uid).upcase
+    end
+
+    ###
+    # Inspect this tag
+    def inspect
+      string_ary =
+        [ "(NFC) ISO14443A Tag",
+          " ATQA (SENS_RES): #{sprintf("%02x  %02x", *atqa)}",
+          "    UID (NFCID1): #{to_s '  '}",
+          "   SAK (SEL_RES): #{sprintf("%02x", btSak)}"
+        ]
+      if szAtsLen > 0
+        ats = sprintf((['%02x'] * szAtsLen).join('  '), *self.ats)
+        string_ary << "       ATS (ATR): #{ats}"
+      end
+      string_ary.join "\n"
+    end
+  end
+end

data/test/test_context.rb

@@ -0,0 +1,22 @@
+require "minitest/autorun"
+require "nfc"
+
+module NFC
+  class TestContext < Minitest::Test
+    def test_init
+      assert NFC::Context.new
+    end
+
+    def test_list_devices
+      ctx = NFC::Context.new
+      assert ctx.devices(1)
+    end
+
+    def test_open
+      ctx = NFC::Context.new
+      devs = ctx.devices(1)
+      skip "no devs attached" unless devs.length > 0
+      dev = ctx.open nil
+    end
+  end
+end

data/test/test_device.rb

@@ -0,0 +1,15 @@
+require "minitest/autorun"
+require "nfc"
+
+module NFC
+  class TestDevice < Minitest::Test
+    def test_initiator_init
+      ctx = NFC::Context.new
+      devs = ctx.devices(1)
+      skip "no devs attached" unless devs.length > 0
+      dev = ctx.open nil
+      dev.initiator_init
+      dev.select_passive_target Device::IM_ISO14443A_106
+    end
+  end
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: tamashii-nfc
+version: !ruby/object:Gem::Version
+  version: 3.1.2
+platform: ruby
+authors:
+- Aaron Patterson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-09-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.16'
+description: |-
+  NFC is a ruby wrapper for the Near Field Communication library.  The Near
+  Field Communication library works with many USB RFID readers, so this gem
+  lets you read RFID tags.
+email:
+- aaron@tenderlovemaking.com
+executables:
+- nfc
+extensions:
+- ext/nfc/extconf.rb
+extra_rdoc_files:
+- CHANGELOG.rdoc
+- Manifest.txt
+- README.rdoc
+files:
+- ".autotest"
+- CHANGELOG.rdoc
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- bin/nfc
+- ext/nfc/context.c
+- ext/nfc/extconf.rb
+- ext/nfc/nfc.c
+- ext/nfc/nfc.h
+- ext/nfc/nfc_device.c
+- ext/nfc/nfc_felica.c
+- ext/nfc/nfc_iso14443a.c
+- lib/nfc.rb
+- lib/nfc/device.rb
+- lib/nfc/felica.rb
+- lib/nfc/iso14443a.rb
+- test/test_context.rb
+- test/test_device.rb
+homepage: http://seattlerb.rubyforge.org
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: NFC is a ruby wrapper for the Near Field Communication library
+test_files: []