nfclib 0.0.128

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9aa76f9d24205d6d1be2c84a17d72f90181b5772
+  data.tar.gz: 1784f373e270807a65f1ed3b28a60181f141e35d
+SHA512:
+  metadata.gz: 509197bfc7bf3deaf94dabc5b27eb9b7c271a19f957e6854388f5fd9c76c56885a558165789dc40f96a07501dba60ae7dd3883f4f259c6bacf537d0123fa744a
+  data.tar.gz: 939e608a5a176e1dc364f884691c94029d78cef622bbb1e88a14d15de4e75f417c28099be0238bae0533c8ad9b24e3eb52fdbbad2da069b2d4f6626830875a4e

data/README.md

@@ -0,0 +1,4 @@
+lagiacrus
+=========
+
+NFC-LIB

data/ext/extconf.rb

@@ -0,0 +1,12 @@
+require 'mkmf'
+
+spec = eval(File.read(File.dirname(__FILE__) + '/../nfclib.gemspec'))
+PKG_NAME="nfclib"
+
+$CFLAGS = '-Wall -pedantic -O3 -c -fPIC ' + $CFLAGS
+$LDFLAGS = '-pthread ' + $LDFLAGS
+$LIBPATH.push(RbConfig::CONFIG['libdir'])
+
+
+create_header()
+create_makefile(PKG_NAME)

data/ext/nfclib.c

@@ -0,0 +1,467 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <termios.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <string.h>
+#include <ctype.h>
+#include "nfclib.h"
+
+void (**nfc_what_happens_if)(nfc_reader* x) = NULL;
+int what_happens_len;
+int what_happens_max_len;
+
+/*nfc_set_cmd # {{{ */
+int nfc_set_cmd(nfc_reader* x,char* str){
+ 
+  int str_len = strlen(str);
+  int i = 0;
+  if(!str_len) 
+    return 1;
+  for(;i<str_len;i++) 
+    x->command[i]=(uint8_t) str[i];
+  x->command_len = i;
+  return 0;
+}
+/* # }}}*/
+
+
+/* expand # {{{ */
+void dance_the_expanding_dance(nfc_reader *x){
+
+  int i;
+  void(**temp)(nfc_reader* y) = malloc(((x->what_happens_max_len)+2) * sizeof(void (*)(nfc_reader*)));
+  for(i=0;i<(x->what_happens_len);i++){
+    temp[i] = (x->nfc_what_happens_if)[i];
+  }
+  free((x->nfc_what_happens_if));
+/* fprintf(stdout,"YES, WE DANCED!\n"); */
+  (x->nfc_what_happens_if)=temp;
+}
+/* # }}}*/
+
+/* nfc_reader_on_tag # {{{ */
+void* nfc_reader_on_tag(nfc_reader* x,void (*y)(nfc_reader*)){
+  if(x->nfc_what_happens_if == NULL){
+    x->what_happens_len = 0;
+    x->what_happens_max_len = 2;
+    x->nfc_what_happens_if = malloc(2 * sizeof(void (*)(nfc_reader*)));
+  }
+  if((x->what_happens_len)==(x->what_happens_max_len)){
+    dance_the_expanding_dance(x);
+  }
+  (x->nfc_what_happens_if)[((x->what_happens_len))++] = y;
+  return NULL;
+}
+/* # }}}*/
+
+/* nfc_reader_init # {{{ */
+nfc_reader* nfc_reader_init(const char* name, int mem_len) {
+  nfc_reader* xptr;
+  nfc_reader x;
+  int len = strlen(name);
+  int i;
+  struct termios tconfig;
+  x.nfc_port = (char*) malloc(sizeof(char)*(len+1));
+  for(i = 0;i<len;i++) 
+    x.nfc_port[i] = name[i];
+  x.nfc_port[i] = '\0';
+  x.fh = open(x.nfc_port,O_RDWR|O_NOCTTY|O_NONBLOCK);
+  if(x.fh==-1) 
+    byebye("Could not open a filehandler for writing\n");
+/* TCONFIG #{{{ */
+  tconfig.c_cc[VTIME] = 3;
+  tconfig.c_cc[VMIN] = 5;
+  /* Tconfig setup */ 
+  tconfig.c_iflag &= ~(IGNBRK|ISTRIP|IXON);
+  tconfig.c_lflag &= ~(ECHO | ECHONL | ICANON | IEXTEN | ISIG); 
+  tconfig.c_cflag &= ~(CSIZE | PARENB);
+  tconfig.c_cflag |= CS8;
+  tconfig.c_oflag &= ~(OPOST); 
+  if(cfsetispeed(&tconfig, B115200) < 0 || cfsetospeed(&tconfig, B115200) < 0) 
+    fprintf(stderr,"ERROR %s:%d\n",__FILE__,__LINE__);
+  if(tcsetattr(x.fh, TCSANOW, &tconfig) < 0)
+    fprintf(stderr,"ERROR %s:%d\n",__FILE__,__LINE__);
+/* # }}} */  
+  
+  x.reddit = (unsigned char*) malloc(sizeof(unsigned char)*100);
+  x.reddit_len = 0;
+  x.command_len = 0;
+  x.what_happens_len = 0;
+  x.what_happens_max_len = 0;
+  x.nfc_what_happens_if=NULL;
+  x.tag_mem_max_len = mem_len;
+  x.tag_mem_len = 0;
+  x.tag_mem_block_len = 4 ;
+  x.tag_mem = (unsigned char*) malloc(sizeof(unsigned char)*(mem_len*((x.tag_mem_block_len)+1))) ;
+  xptr = malloc(sizeof(nfc_reader)*1);
+  *xptr = x;
+  return xptr;
+}
+/* # }}}*/
+
+/* nfc_reader_do # {{{ */
+void* nfc_reader_do(void* y){
+    nfc_reader* x= y;
+    int write_pos = 0;
+    int i;
+    int j=0;
+    int limit = -1;
+    int len = x->command_len;
+    int read_bytes;
+    int b_read =0;
+    int tries = 0;
+    int max_tries = 2;
+    unsigned char bcc = 0;
+    unsigned char ucmd [50];
+    fd_set set;
+    int written_bytes;
+    struct timeval timeout;
+    timeout.tv_sec=1;
+    timeout.tv_usec=0;
+    for(i=0;i<len;i++){
+      if(isalpha((x->command)[i])){
+        ucmd[j++] = (x->command)[i];
+      }
+      if(isdigit((x->command)[i])){
+        int temp = (x->command)[i++] - '0';
+        while(i<len && isdigit((x->command)[i])){
+          temp *= 10;
+          temp += (x->command)[i++] - '0';
+        }
+        if(temp>255) 
+          byebye("Adresse zu groß");
+        ucmd[j++] = temp;
+        if(i==len)
+          break;
+      }
+    }
+    /*CLEAR */
+    written_bytes = write(x->fh,"\0",1);
+    ucmd[j] = '\0';
+    x->write_puffer[write_pos++] = 2;
+    x->write_puffer[write_pos++] = 255;
+    x->write_puffer[write_pos++] = ustrlen(ucmd);
+    for(i=0;i<ustrlen(ucmd);i++)
+      x->write_puffer[write_pos++] = ucmd[i];
+    for(i=1;i<(len)+3;i++) 
+      bcc ^= x->write_puffer[i];
+    x->write_puffer[write_pos++] = bcc;
+    x->write_puffer[write_pos++] = 3;
+/*    for(i=0;i<write_pos;i++)
+      fprintf(stderr,"written: %d\n",(x->write_puffer)[i]);
+*/    
+    
+    for(tries=0;tries<max_tries;){
+      written_bytes = write(x->fh,x->write_puffer,write_pos);
+      if(written_bytes != write_pos){
+        fprintf(stderr,"Error while writing\n");
+        return y;
+      }
+      j=0;
+      while(1){
+        /* INITIALIZE FD READ SET */
+        FD_ZERO (&set);
+        FD_SET (x->fh,&set);
+        
+        if(select(FD_SETSIZE,&set,NULL,NULL,&timeout)>0){
+          if((read_bytes=read(x->fh,x->read_puffer,37))>0){
+            for(i=0;i<read_bytes;i++,j++)
+              (x->reddit)[j] = (x->read_puffer)[i];
+            
+            if(j>2 && limit==-1) limit=(x->reddit)[2]+5;
+            b_read+=read_bytes;
+          }
+          if(b_read==limit) {
+            x->reddit_len = b_read;
+            tries=max_tries;
+            break;
+          }
+          if(limit!=-1 && b_read>limit){
+            /*
+            fprintf(stdout,"Error. Read too many bytes\n");
+            */
+            x->reddit_len = 0;
+            break;
+          }
+        }
+        else{
+  /*        
+          int ii= 0;
+          fprintf(stderr,"Read Bytes: %d\n",b_read);
+          fprintf(stderr,"Expected: %d\n",limit);
+          
+          for(ii=0;ii<b_read;ii++)
+            fprintf(stderr,"Read: %d\n",(x->reddit)[ii]);
+          fprintf(stdout,"Could not catch the correct length of the answer\n");
+  */
+          x->reddit_len = 0;
+          break;
+        }
+      }
+      tries++;
+      if(nfc_what_happens_if!=NULL)
+        nfc_what_happens_if[(0)](x);
+    }
+    return y;  /*Bessere Returns; */
+}
+/*  # }}}*/
+
+/*nfc_reader_poll # {{{ */
+int nfc_reader_poll(nfc_reader* x){
+  int rc;
+  rc = pthread_create(&(x->polling),NULL,&nfc_reader_read,x);
+  if( rc != 0)
+    byebye("Problem bei Threaderzeugung\n");
+  return 0;
+}
+/* # }}}*/
+
+/* nfc_reader_stop_poll # {{{ */
+int nfc_reader_stop_poll(nfc_reader* x){
+  int ret = pthread_cancel(x->polling);
+  pthread_join(x->polling,NULL); 
+  return ret;
+}
+/* # }}}*/
+
+/* Use in a Thread */
+/* nfc_reader_read # {{{ */
+void* nfc_reader_read(void *y){
+  nfc_reader *x = y;
+  int read_bytes;
+  fd_set set;
+  struct timeval timeout;
+  int i,j=0;
+  int limit=-1;
+  int b_read = 0;
+  pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);
+  while(1){
+    /* INITIALIZE FD READ SET */
+    timeout.tv_sec=1;
+    timeout.tv_usec=0;
+    FD_ZERO (&set);
+    FD_SET (x->fh,&set);
+    if(select(FD_SETSIZE,&set,NULL,NULL,&timeout)>0){ 
+      if((read_bytes=read(x->fh,x->read_puffer,3))>0){
+        for(i=0;i<read_bytes;i++,j++)
+          (x->reddit)[j] = x->read_puffer[i];
+        b_read += read_bytes;
+        if(limit==-1 && b_read>3)
+          limit = (x->reddit)[2]+5;
+      }
+      if(limit==b_read){
+        int count;
+        x->reddit_len=b_read;
+        if((x->nfc_what_happens_if)!=NULL){
+          for(count=0;count<(x->what_happens_len);count++)
+            (x->nfc_what_happens_if)[(count)](x);
+        }
+/*        nfc_reader_read_mem(x); */
+        j=0;
+        b_read =0;
+        limit=-1;
+      }
+      if(limit!=-1 && b_read>limit){
+/*        
+        fprintf(stdout,"Error. Read too many bytes\n");
+*/        
+        limit=-1;
+        b_read=0;
+        j=0;
+      }
+    }
+    else{
+      if(limit!=-1){
+        int testi = 0;
+        fprintf(stdout,"Seltsam hier zu sein B_Read: %d  Limit: %d\n",b_read,limit);
+        for(testi=0;testi<b_read;testi++){
+          fprintf(stdout,"%d\t",(x->reddit)[testi]);
+        }
+        fprintf(stdout,"\n");
+         limit = -1;
+        j=0;
+        b_read =0;
+      }
+    }
+  }
+}
+/* # }}}*/
+/* # {{{  nfc_reader_read_mem */
+void nfc_reader_read_mem(nfc_reader* x){
+
+  int i,count;
+  unsigned char* tag_mems= x->tag_mem;
+  char str[10];
+  x->tag_mem[0] ='\0';
+  nfc_set_cmd(x,"s");
+  nfc_reader_do(x);
+  nfc_reader_do(x);
+  for(i=4;i<8;i++){
+/*  for(i=4;i<(x->tag_mem_max_len);i++){ */
+    x->reddit_len = 0;
+    while((x->reddit_len)==0){
+      sprintf(str,"r%d",i);
+      nfc_set_cmd(x,str);
+      nfc_reader_do(x);
+/*      
+      fprintf(stdout,"READ_MEM: %d\n",x->reddit_len);
+*/      
+      if((x->reddit_len)==(5+(x->tag_mem_block_len))){
+        int j;
+        int hex;
+        char test[9];
+        char temp[3];
+        char* ptemp = &(temp[0]);
+        char* p_test= &(test[0]);
+        if((x->reddit)[6] == 0) break;
+        for(j=3;j<((x->reddit_len)-2);j++){
+/*          fprintf(stdout,"%02x ",(x->reddit)[j]);
+*/
+          sprintf(ptemp,"%02x",(x->reddit)[j]);
+          if(j==3){
+            strcpy(p_test,ptemp);
+            if(i==4) strcpy((x->tag_mem),ptemp);
+            else strcat(tag_mems,ptemp);
+            tag_mems+=4;
+            *tag_mems='\0';
+            tag_mems++;
+          }
+          else{
+            strcat(p_test,ptemp);
+            strcat(tag_mems,ptemp);
+            tag_mems+=4;
+            *tag_mems='\0';
+            tag_mems++;
+          }
+        }
+/*        
+        hex = (int)strtol(p_test,NULL,16);
+        fprintf(stdout,"%s\n",p_test);
+        fprintf(stdout,"%d\n",hex);
+        fprintf(stdout,"\n");
+*/
+      }
+/*
+      if((x->nfc_what_happens_if)!=NULL){
+        for(count=0;count<(x->what_happens_len);count++)
+          (x->nfc_what_happens_if)[(count)](x);
+      }
+*/
+      if((x->reddit_len)==0 || (x->reddit_len)==6){
+        nfc_set_cmd(x,"s");
+        nfc_reader_do(x);
+        x->reddit_len = 0;
+      }
+    }
+    if((x->reddit)[6] == 0) break;
+
+  }
+  
+  for(i=0;i<(x->tag_mem_max_len);i+=((x->tag_mem_block_len)+1)){
+    if((x->tag_mem)[i]=='\0') break;
+/*
+    else {
+      fprintf(stdout,"String: %s",(x->tag_mem));
+      fprintf(stdout,"HUCH: %c \n",(x->tag_mem)[5]);
+      fprintf(stdout,"HUCH: %c \n",(x->tag_mem)[10]);
+      fprintf(stdout,"\n");
+    }
+*/
+  }
+  sleep(1);
+  nfc_set_cmd(x,"dp");
+  nfc_reader_do(x);
+}
+/* # }}}  */
+
+/* nfc_reader_1_read # {{{ */
+void* nfc_reader_1_read(void *y){
+  nfc_reader *x = y;
+  int read_bytes;
+  fd_set set;
+  struct timeval timeout;
+  int i,j=0;
+  int limit=-1;
+  int b_read = 0;
+  while(1){
+    /* INITIALIZE FD READ SET */
+    timeout.tv_sec=1;
+    timeout.tv_usec=0;
+    FD_ZERO (&set);
+    FD_SET (x->fh,&set);
+    if(select(FD_SETSIZE,&set,NULL,NULL,&timeout)>0){ 
+      if((read_bytes=read(x->fh,x->read_puffer,3))>0){
+        for(i=0;i<read_bytes;i++,j++)
+          (x->reddit)[j] = x->read_puffer[i];
+        b_read += read_bytes;
+        if(limit==-1 && b_read>3)
+          limit = (x->reddit)[2]+5;
+      }
+      if(limit==b_read){
+        int count;
+        x->reddit_len=b_read;
+        if((x->nfc_what_happens_if)!=NULL){
+          for(count=0;count<(x->what_happens_len);count++)
+            (x->nfc_what_happens_if)[(count)](x);
+        }
+        j=0;
+        b_read =0;
+        limit=-1;
+        break;
+      }
+      if(limit!=-1 && b_read>limit){
+        fprintf(stdout,"Error. Read too many bytes\n");
+        limit=-1;
+        b_read=0;
+        j=0;
+        break;
+      }
+    }
+    else{
+      if(limit!=-1){
+        limit = -1;
+        j=0;
+        b_read =0;
+        fprintf(stdout,"Selstam hier zu sein\n");
+        break;
+      }
+    }
+  }
+  return y;
+}
+/* # }}} */
+
+/* nfc_reader_destroy # {{{ */
+int nfc_reader_destroy(nfc_reader* x){
+  if(x!=NULL){
+    if(x->reddit != NULL)
+      free(x->reddit);
+    if(x->nfc_port != NULL)
+      free(x->nfc_port);
+    if((x->nfc_what_happens_if) != NULL)
+      free((x->nfc_what_happens_if));
+    if((x->tag_mem)!=NULL)
+      free(x->tag_mem);
+    free(x);
+  }
+  return 0;
+}
+/* # }}}*/
+
+/* byebye # {{{ */
+void byebye(char *str){
+  fprintf(stderr,"Error\nErrormsg: %s\n",str);
+  exit(EXIT_FAILURE);
+}
+/* # }}}*/
+
+/* ustrlen # {{{ */
+int ustrlen(unsigned char* str){
+  int ret;
+  for(ret=0;str[ret]!='\0';ret++);
+  return ret;
+
+}
+/* # }}}*/

data/ext/nfclib.h

@@ -0,0 +1,43 @@
+#ifndef NFCLIB_H
+#define NFCLIB_H
+
+#include <pthread.h>
+#include <stdint.h>
+
+struct nfc_struct;
+
+typedef struct nfc_struct{
+  char* nfc_port;  /* Port of NFC_Reader, e.g '/dev/ttyUSB0' , gets initialize with nfc_reader_init(); */
+  int fh;
+  pthread_t polling;
+  uint8_t read_puffer[100];
+  uint8_t write_puffer[100];
+  uint8_t* reddit;
+  int reddit_len;
+  unsigned char* tag_mem;
+  int tag_mem_max_len;
+  int tag_mem_len;
+  int tag_mem_block_len;
+  uint8_t command[100];
+  int command_len;
+  int what_happens_len;
+  int what_happens_max_len;
+  void (**nfc_what_happens_if)(struct nfc_struct* x);
+} nfc_reader ;
+
+
+void* nfc_reader_on_tag(nfc_reader* x,void (*y)(nfc_reader*));
+
+nfc_reader* nfc_reader_init(const char* name,int mem_len);
+int nfc_reader_stop_poll(nfc_reader*);
+int nfc_reader_poll( nfc_reader*);
+int nfc_reader_destroy(nfc_reader* x);
+void* nfc_reader_read(void* y);
+void byebye(char *str); 
+void* nfc_reader_do(void* y);
+void set_cmd(nfc_reader *x,char * y);
+int ustrlen(unsigned char* str);
+int nfc_set_cmd(nfc_reader* x,char* str);
+void* nfc_reader_1_read(void *y);
+void nfc_reader_read_mem(nfc_reader* x);
+#endif /* NFCLIB_H */

data/lib/nfc.rb

@@ -0,0 +1,112 @@
+require 'ffi'
+
+module NFC
+  # FFI #{{{
+    extend FFI::Library
+    ffi_lib ::File.dirname(__FILE__) + '/nfclib.so'
+    callback :on_tag_callback, [:pointer], :void
+    attach_function :nfc_reader_on_tag, [:pointer,:on_tag_callback], :pointer
+    attach_function :nfc_reader_init, [:string,:int], :pointer
+    attach_function :nfc_reader_poll, [:pointer], :int
+    attach_function :nfc_reader_stop_poll, [:pointer], :int
+    attach_function :nfc_reader_destroy, [:pointer], :int
+    attach_function :nfc_reader_read, [:pointer], :void
+    attach_function :nfc_reader_do, [:pointer], :void
+    attach_function :byebye, [:string], :void 
+    attach_function :ustrlen, [:string], :void
+    attach_function :nfc_reader_1_read, [:pointer], :pointer
+    attach_function :nfc_set_cmd, [:pointer, :string], :int; 
+  #}}}
+
+  class Struct < FFI::Struct #{{{
+    layout  :nfc_port, :string,
+            :fh, :int,
+            :polling, :pthread_t,
+            :read_puffer, [:u_int8_t, 100],
+            :write_puffer, [:u_int8_t,100],
+            :reddit, :pointer,
+            :reddit_len, :int,
+            :tag_mem, [:pointer,36],
+            :tag_mem_max_len, :int,
+            :tag_mem_len, :int,
+            :tag_mem_block_len, :int,
+            :command, [:u_int8_t,100],
+            :command_len, :int,
+            :what_happens_len, :int,
+            :what_happens_max_len, :int,
+            :nfc_what_happens_if, :pointer
+  end #}}}
+
+  class Result #{{{ 
+    def initialize(res)
+      @res = res.unpack("C*") 
+    end
+
+    def hex
+      @res.map{|e| e.to_s(16) }
+    end
+    def dec
+      @res
+    end
+  end #}}}
+
+  class Reader
+    attr_reader :reader
+    attr_accessor :serialnr 
+    def initialize(tty = "/dev/ttyUSB0",mem_len=36) #{{{
+      @reader = NFC.nfc_reader_init(tty,mem_len)
+      @thread = nil
+      @serialnr = nil
+      command('x')
+
+      begin
+        @serialnr = command('b')
+      end while @serialnr == nil
+      p "SERIAL"
+      p @serialnr
+      p '-' * 24
+      Signal::trap("INT") do
+        puts 'stopping...'
+        stop_poll
+        @thread.kill
+      end
+    end #}}} 
+
+    def command( cmd) #{{{
+      obj = Struct.new(@reader)
+      NFC.nfc_set_cmd(@reader,cmd)
+      NFC.nfc_reader_do(@reader)
+      obj[:reddit].read_string(obj[:reddit_len])[3..-3] 
+    end #}}}
+
+    def command_print(cmd) #{{{
+      obj = Struct.new(@reader)
+      NFC.nfc_set_cmd(@reader,cmd)
+      NFC.nfc_reader_do(@reader)
+      if (obj[:reddit].read_string(obj[:reddit_len])[3..-3]== nil)
+        temp = nil
+      else
+        temp=Result.new(obj[:reddit].read_string(obj[:reddit_len])[3..-3])
+      end
+      p temp
+    end #}}} 
+    
+    def read_once #{{{
+      NFC.nfc_reader_1_read(@reader)
+    end #}}}
+    def stop_poll #{{{
+      NFC.nfc_reader_stop_poll(@reader)
+    end #}}}
+    def poll(&bl) #{{{
+      pr = Proc.new do |obj|
+        obj = Struct.new(@reader)
+        bl.call(Result.new(obj[:reddit].read_string(obj[:reddit_len])[3..-3]))
+      end
+      NFC.nfc_reader_on_tag(@reader,pr)
+      command('dp')
+      NFC.nfc_reader_poll(@reader)
+      @thread = Thread.new { Thread::stop }
+      @thread.join
+    end #}}}
+  end
+end  

data/nfclib.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |s|
+  s.name = 'nfclib'
+  s.version = '0.0.128'
+  s.date = '2014-08-05'
+  s.summary ="NFC-Reader Library."
+  s.description ="Executes command and gets results in c, everthing else ruby-yo"
+  s.authors = ["Florian Stertz"]
+  s.email = ['florian.stertz@gmail.com']
+  s.files = Dir['ext/extconf.rb'] + Dir['lib/nfc.rb'] + ['nfclib.gemspec','README.md'] + Dir['ext/nfclib.c'] + Dir['ext/nfclib.h']
+  s.platform = Gem::Platform::RUBY
+  s.require_paths = ['lib']
+  s.extensions = Dir['ext/extconf.rb']
+  s.homepage = 'https://github.com/Triarier/lagiacrus'
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: nfclib
+version: !ruby/object:Gem::Version
+  version: 0.0.128
+platform: ruby
+authors:
+- Florian Stertz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-05 00:00:00.000000000 Z
+dependencies: []
+description: Executes command and gets results in c, everthing else ruby-yo
+email:
+- florian.stertz@gmail.com
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- README.md
+- ext/extconf.rb
+- ext/nfclib.c
+- ext/nfclib.h
+- lib/nfc.rb
+- nfclib.gemspec
+homepage: https://github.com/Triarier/lagiacrus
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.2.2
+signing_key: 
+specification_version: 4
+summary: NFC-Reader Library.
+test_files: []