vs_projects/Matomat
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

bla

Browse Source
This commit is contained in:
BlubbFish
2015-11-15 18:18:42 +00:00
parent 9ac343fc45
commit 72be7b0c2f
580 changed files with 356252 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files
librfid/python/Makefile
+51
View File
@@ -0,0 +1,51 @@
# Makefile for Python bindings
# (C) 2007-2008 by Kushal Das <kushal@openpcd.org>
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2
# as published by the Free Software Foundation
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
CC=gcc
PYTHON=python
PREFIX=/usr
PYTHON_VER=2.5
PYTHON_INC=$(PREFIX)/include/python$(PYTHON_VER)
PYTHON_LIB=$(PREFIX)/lib/python$(PYTHON_VER)/site-packages/
LIBRFID_DIR=../src/.libs
SOURCE_MAIN=pyrfid.c
SOURCES=$(SOURCE_MAIN) openpcd.c
INCLUDES=-I$(PYTHON_INC) -I../include/ -I../utils/
CFLAGS=-O3 -Wall $(INCLUDES)
LDFLAGS=-shared -L$(LIBRFID_DIR) -lrfid -lusb -Wl,--rpath -Wl,/usr/local/lib $(LIBS)
TARGET=$(SOURCE_MAIN:.c=.so)
OBJECTS=$(SOURCES:.c=.o)
all: $(SOURCE_MAIN) $(TARGET)
test:
$(PYTHON) $@.py
install: $(TARGET)
install $(TARGET) $(PYTHON_LIB)
$(TARGET): $(OBJECTS)
$(CC) $(LDFLAGS) -o $@ $(OBJECTS)
.c.o:
$(CC) $(CFLAGS) -c $< -o $@
clean:
rm -f $(OBJECTS) $(TARGET)
librfid/python/openpcd.c
+345
View File
@@ -0,0 +1,345 @@
/*************************************************************************/
/* */
/* Mifare support for accessing RFID cards with OpenPCD RFID reader */
/* in WIN32 - see http://www.openpcd.org */
/* */
/* Copyright (C) 2007 Milosch Meriac <meriac@bitmanufaktur.de> */
/* */
/* Redistribution and use in source and binary forms, with or without */
/* modification, are permitted provided that the following conditions are*/
/* met: */
/* */
/* Redistributions of source code must retain the above copyright notice,*/
/* this list of conditions and the following disclaimer. */
/* Redistributions in binary form must reproduce the above copyright */
/* notice, this list of conditions and the following disclaimer in the */
/* documentation and/or other materials provided with the distribution. */
/* */
/* The name of the author may not be used to endorse or promote products */
/* derived from this software without specific prior written permission. */
/* */
/* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR */
/* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED */
/* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE*/
/* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, */
/* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES */
/* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR */
/* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) */
/* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, */
/* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING */
/* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE */
/* POSSIBILITY OF SUCH DAMAGE. */
/* */
/*************************************************************************/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <librfid/rfid.h>
#include <librfid/rfid_scan.h>
#include <librfid/rfid_reader.h>
#include <librfid/rfid_protocol.h>
#include <librfid/rfid_protocol_mifare_classic.h>
#define BUILD_DLL
#include "openpcd.h"
#define LIBMIFARE_MAGIC 0xDEADBEEF
struct openpcd_state
{
unsigned int magic;
unsigned int cl_auth;
struct rfid_reader_handle *rh;
struct rfid_layer2_handle *l2h;
struct rfid_protocol_handle *ph;
unsigned char key[MIFARE_CL_KEY_LEN];
unsigned int uid;
} openpcd_state;
int openpcd_cl_auth(struct openpcd_state* state ,int page)
{
int rc;
if(!state || page<=0 || page>MIFARE_CL_PAGE_MAX )
return PCDERROR_INVALID_PARAMETER;
if(!state->ph)
return PCDERROR_CLOSED;
rc = mfcl_set_key(state->ph, state->key);
if (rc < 0)
return PCDERROR_KEY_FORMAT;
rc = mfcl_auth(state->ph, state->cl_auth, page);
return rc<0 ? PCDERROR_KEY_AUTH : PCDERROR_NONE;
}
void Sleep(unsigned int ms ) {
usleep(ms*1000);
}
EXPORT int EXPORT_CONVENTION openpcd_set_key(MIFARE_HANDLE handle,unsigned int key_id,const void* key)
{
struct openpcd_state *state;
if(!handle)
return PCDERROR_INVALID_PARAMETER;
state=(struct openpcd_state*)handle;
switch(key_id)
{
case PCDAUTH_KEYID_1A:
state->cl_auth=RFID_CMD_MIFARE_AUTH1A;
break;
case PCDAUTH_KEYID_1B:
state->cl_auth=RFID_CMD_MIFARE_AUTH1B;
break;
default:
return PCDERROR_INVALID_PARAMETER;
}
memcpy(state->key,key,MIFARE_CL_KEY_LEN);
return PCDERROR_NONE;
}
EXPORT int EXPORT_CONVENTION openpcd_select_card(MIFARE_HANDLE handle)
{
int res;
struct openpcd_state *state;
if(!handle)
return PCDERROR_INVALID_PARAMETER;
state=(struct openpcd_state*)handle;
state->l2h = rfid_layer2_init(state->rh,RFID_LAYER2_ISO14443A);
if(!state->l2h)
res=PCDERROR_LAYER2_INIT;
else
{
if( rfid_layer2_open(state->l2h)>=0 )
{
state->ph = rfid_protocol_init(state->l2h,RFID_PROTOCOL_MIFARE_CLASSIC);
if(state->ph)
{
if(rfid_protocol_open(state->ph)>=0)
return PCDERROR_NONE;
rfid_protocol_fini(state->ph);
state->ph=NULL;
res=PCDERROR_LAYER3_OPEN;
}
else
res=PCDERROR_LAYER3_INIT;
rfid_layer2_close(state->l2h);
}
else
res=PCDERROR_LAYER2_OPEN;
}
rfid_layer2_fini(state->l2h);
state->l2h=NULL;
return res;
}
EXPORT int EXPORT_CONVENTION openpcd_deselect_card(MIFARE_HANDLE handle)
{
struct openpcd_state *state;
if(!handle)
return PCDERROR_INVALID_PARAMETER;
state=(struct openpcd_state*)handle;
if(state->ph)
{
rfid_protocol_close(state->ph);
rfid_protocol_fini(state->ph);
rfid_layer2_close(state->l2h);
rfid_layer2_fini(state->l2h);
state->ph=NULL;
state->l2h=NULL;
state->uid=0;
return PCDERROR_NONE;
}
else
return PCDERROR_CLOSED;
}
EXPORT int EXPORT_CONVENTION openpcd_get_card_id(MIFARE_HANDLE handle,unsigned int *uid)
{
unsigned int uid_len;
struct openpcd_state *state;
if(!handle || !uid)
return PCDERROR_INVALID_PARAMETER;
state=(struct openpcd_state*)handle;
if(state->ph)
{
uid_len=sizeof(*uid);
if(rfid_layer2_getopt(state->l2h,RFID_OPT_LAYER2_UID,uid,&uid_len))
return PCDERROR_INVALID_PARAMETER;
else
return uid_len==4 ? PCDERROR_NONE:PCDERROR_READ_FAILED;
}
else
return PCDERROR_CLOSED;
}
EXPORT int EXPORT_CONVENTION openpcd_open_reader(MIFARE_HANDLE *handle)
{
struct rfid_reader_handle *rh;
struct openpcd_state *state;
if(!handle)
return PCDERROR_INVALID_PARAMETER;
rh = rfid_reader_open(NULL, RFID_READER_OPENPCD);
if(!rh)
return PCDERROR_NO_READER;
state=(struct openpcd_state*)malloc(sizeof(*state));
if(state)
{
memset(state,0,sizeof(*state));
state->magic=LIBMIFARE_MAGIC;
state->rh=rh;
state->cl_auth=RFID_CMD_MIFARE_AUTH1A;
memset(state->key,0xFF,sizeof(state->key));
// do initial reset
openpcd_reset_reader((MIFARE_HANDLE)state);
Sleep(1500);
// reopen
state->rh = rfid_reader_open(NULL, RFID_READER_OPENPCD);
*handle=(MIFARE_HANDLE)state;
return PCDERROR_NONE;
}
else
{
rfid_reader_close(rh);
return PCDERROR_OUT_OF_MEMORY;
}
}
EXPORT int EXPORT_CONVENTION openpcd_close_reader(MIFARE_HANDLE handle)
{
struct openpcd_state *state;
if(!handle)
return PCDERROR_INVALID_PARAMETER;
state=(struct openpcd_state*)handle;
openpcd_deselect_card(handle);
openpcd_reset_reader(handle);
Sleep(500);
state->magic=0;
rfid_reader_close(state->rh);
free(state);
return PCDERROR_NONE;
}
EXPORT int EXPORT_CONVENTION openpcd_read(MIFARE_HANDLE handle,int page, void* data, int len)
{
int res;
unsigned int count;
unsigned char buf[MIFARE_CL_PAGE_SIZE];
struct openpcd_state *state;
if( !handle || !buf || page<0 || page>MIFARE_CL_PAGE_MAX || len<=0 || len>sizeof(buf))
return PCDERROR_INVALID_PARAMETER;
state=(struct openpcd_state*)handle;
if ( (res=openpcd_cl_auth(state,page)) < 0)
return res;
count = sizeof(buf);
res = rfid_protocol_read(state->ph, page, buf, &count);
if(res>=0)
memcpy(data,buf,len);
if ( res<0 )
return PCDERROR_READ_FAILED;
else
return count;
}
EXPORT int EXPORT_CONVENTION openpcd_write(MIFARE_HANDLE handle,int page,const void *data,int len)
{
int res;
unsigned char buf[16];
struct openpcd_state *state;
if( !handle || !buf || page<0 || page>MIFARE_CL_PAGE_MAX || len<=0 || len>sizeof(buf))
return PCDERROR_INVALID_PARAMETER;
state=(struct openpcd_state*)handle;
if ( (res=openpcd_cl_auth(state,page)) < 0)
return res;
memcpy(buf,data,len);
memset(&buf[len],0,sizeof(buf)-len);
res = rfid_protocol_write(state->ph, page, buf, sizeof(buf));
return (res<0 && res!=-101) ? PCDERROR_WRITE_FAILED : len;
}
EXPORT int EXPORT_CONVENTION openpcd_reset_reader(MIFARE_HANDLE handle)
{
struct openpcd_state *state;
if( !handle )
return PCDERROR_INVALID_PARAMETER;
state=(struct openpcd_state*)handle;
return (state->rh->reader->reset(state->rh)<0) ? PCDERROR_WRITE_FAILED : PCDERROR_NONE;
}
EXPORT char* EXPORT_CONVENTION openpcd_get_error_text(int error)
{
const static char* msg[]={
"PCDERROR_NONE", // 0
"PCDERROR_INVALID_PARAMETER", // -1
"PCDERROR_KEY_FORMAT", // -2
"PCDERROR_KEY_AUTH", // -3
"PCDERROR_NO_CARD_FOUND", // -4
"PCDERROR_LAYER2_INIT", // -5
"PCDERROR_LAYER2_OPEN", // -6
"PCDERROR_LAYER3_INIT", // -7
"PCDERROR_LAYER3_OPEN", // -8
"PCDERROR_SELECT", // -9
"PCDERROR_READ_FAILED", // -10
"PCDERROR_WRITE_FAILED", // -11
"PCDERROR_CLOSED", // -12
"PCDERROR_NO_READER", // -13
"PCDERROR_OUT_OF_MEMORY", // -14
"PCDERROR_READER_VERSION" // -15
};
const int count=sizeof(msg)/sizeof(msg[0]);
if(error>0)
error=0;
else
error=-error;
return (error>=count) ? "PCDERROR_UNKNOWN" : (char*)msg[error];
}
librfid/python/openpcd.h
+141
View File
@@ -0,0 +1,141 @@
/*************************************************************************/
/* */
/* Mifare support for accessing RFID cards with OpenPCD RFID reader */
/* in WIN32 - see http://www.openpcd.org */
/* */
/* Copyright (C) 2007 Milosch Meriac <meriac@bitmanufaktur.de> */
/* */
/* Redistribution and use in source and binary forms, with or without */
/* modification, are permitted provided that the following conditions are*/
/* met: */
/* */
/* Redistributions of source code must retain the above copyright notice,*/
/* this list of conditions and the following disclaimer. */
/* Redistributions in binary form must reproduce the above copyright */
/* notice, this list of conditions and the following disclaimer in the */
/* documentation and/or other materials provided with the distribution. */
/* */
/* The name of the author may not be used to endorse or promote products */
/* derived from this software without specific prior written permission. */
/* */
/* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR */
/* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED */
/* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE*/
/* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, */
/* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES */
/* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR */
/* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) */
/* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, */
/* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING */
/* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE */
/* POSSIBILITY OF SUCH DAMAGE. */
/* */
/*************************************************************************/
#ifndef __OPENPCD_H__
#define __OPENPCD_H__
#ifdef __cplusplus
extern "C" {
#endif/*__cplusplus*/
#define EXPORT extern
#define EXPORT_CONVENTION
#define PCDERROR_NONE 0
#define PCDERROR_INVALID_PARAMETER -1
#define PCDERROR_KEY_FORMAT -2
#define PCDERROR_KEY_AUTH -3
#define PCDERROR_NO_CARD_FOUND -4
#define PCDERROR_LAYER2_INIT -5
#define PCDERROR_LAYER2_OPEN -6
#define PCDERROR_LAYER3_INIT -7
#define PCDERROR_LAYER3_OPEN -8
#define PCDERROR_SELECT -9
#define PCDERROR_READ_FAILED -10
#define PCDERROR_WRITE_FAILED -11
#define PCDERROR_CLOSED -12
#define PCDERROR_NO_READER -13
#define PCDERROR_OUT_OF_MEMORY -14
#define PCDERROR_READER_VERSION -15
#define PCDAUTH_KEY_LENGTH 6
#define PCDAUTH_KEYID_1A 0
#define PCDAUTH_KEYID_1B 1
typedef void* MIFARE_HANDLE;
/*************************************************************************/
/* */
/* Six steps for reading/writing to MIFARE cards */
/* */
/*************************************************************************/
/* Step 1. open reader
supply the address of your handle variable to retrieve a handle
to the current reader.
*/
EXPORT int EXPORT_CONVENTION openpcd_open_reader(MIFARE_HANDLE *handle);
/* Step 2. set MIFARE classic key
if your key differs from the default Infineon key (6*0xFF), you can
supply a different key here. The key size is PCDAUTH_KEY_LENGTH bytes.
You can chose to set key_id to PCDAUTH_KEYID_1A or *_1B.
*/
EXPORT int EXPORT_CONVENTION openpcd_set_key(MIFARE_HANDLE handle,unsigned int key_id,const void* key);
/* Step 3. select card
start the anticollosion to select a card in the reader field - retry if
it fails. Currently supports only on card in the readerv field.
*/
EXPORT int EXPORT_CONVENTION openpcd_select_card(MIFARE_HANDLE handle);
/* Step 4. read/write card
read, write from the selected card - specify the page and supply up to
16 bytes of payload
*/
EXPORT int EXPORT_CONVENTION openpcd_read(MIFARE_HANDLE handle,int page, void* data, int len);
EXPORT int EXPORT_CONVENTION openpcd_write(MIFARE_HANDLE handle,int page,const void *data,int len);
/* Step 5. deselect card when done
*/
EXPORT int EXPORT_CONVENTION openpcd_deselect_card(MIFARE_HANDLE handle);
/* Step 6. close reader after deselected card
*/
EXPORT int EXPORT_CONVENTION openpcd_close_reader(MIFARE_HANDLE handle);
/*************************************************************************/
/* */
/* Support functions */
/* */
/*************************************************************************/
/* openpcd_get_error_text:
Used for converting the error code into a string
*/
EXPORT char* EXPORT_CONVENTION openpcd_get_error_text(int error);
/* openpcd_get_card_id:
Get the card id of a selected RFID card
*/
EXPORT int EXPORT_CONVENTION openpcd_get_card_id(MIFARE_HANDLE handle,unsigned int *uid);
/* openpcd_reset_reader:
Reset the attached reader
*/
EXPORT int EXPORT_CONVENTION openpcd_reset_reader(MIFARE_HANDLE handle);
#ifdef __cplusplus
}
#endif/*__cplusplus*/
#endif/*__OPENPCD_H__*/
librfid/python/pyrfid.c
+128
View File
@@ -0,0 +1,128 @@
/* Python bindings for librfid
* (C) 2007-2008 by Kushal Das <kushal@openpcd.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2
* as published by the Free Software Foundation
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <libgen.h>
#include <librfid/rfid.h>
#include <librfid/rfid_scan.h>
#include <librfid/rfid_reader.h>
#include <librfid/rfid_layer2.h>
#include <librfid/rfid_protocol.h>
#include <librfid/rfid_protocol_mifare_classic.h>
#include <librfid/rfid_protocol_mifare_ul.h>
/*#include <common.h>*/
#include "openpcd.h"
#include <Python.h>
static PyObject *pyi_open(PyObject *self, PyObject *args);
static PyObject *pyi_close(PyObject *self, PyObject *args);
static PyObject *pyi_select_card(PyObject *self, PyObject *args);
static PyObject *pyi_deselect_card(PyObject *self, PyObject *args);
static PyObject *pyi_get_card_id(PyObject *self, PyObject *args);
static PyObject *pyi_openpcd_read(PyObject *self, PyObject *args);
static PyObject *pyi_openpcd_write(PyObject *self, PyObject *args);
static PyObject *pyi_set_key(PyObject *self, PyObject *args);
static PyObject *pyi_Error;
MIFARE_HANDLE handle;
static PyMethodDef pyi_Methods[] = {
{"open_reader", pyi_open, METH_VARARGS,
"This will initialise the RFID reader"},
{"close_reader", pyi_close, METH_VARARGS,
"This will close the RFID reader"},
{"select_card", pyi_select_card, METH_VARARGS,
"This will select any card"},
{"read",pyi_openpcd_read, METH_VARARGS,
"This will read the card with given page number"},
{"write",pyi_openpcd_write, METH_VARARGS,
"This will write the card with given page number"},
{"set_key",pyi_set_key, METH_VARARGS,
"This will set the key with given key"},
{"deselect_card", pyi_deselect_card, METH_VARARGS,
"This will deselect any card"},
{"get_card_id", pyi_get_card_id, METH_VARARGS,
"This will get the card id"},
{NULL, NULL, 0, NULL}
};
PyMODINIT_FUNC initpyrfid() {
PyObject *m;
m = Py_InitModule("pyrfid", pyi_Methods);
pyi_Error = PyErr_NewException("pyrfid.error", NULL, NULL);
Py_INCREF(pyi_Error);
PyModule_AddObject(m, "error", pyi_Error);
return;
}
static PyObject *pyi_open(PyObject *self, PyObject *args) {
return Py_BuildValue("i",openpcd_open_reader(&handle));
}
static PyObject *pyi_close(PyObject *self, PyObject *args) {
return Py_BuildValue("i", openpcd_close_reader(handle));
}
static PyObject *pyi_select_card(PyObject *self, PyObject *args) {
return Py_BuildValue("i", openpcd_select_card(handle));
}
static PyObject *pyi_deselect_card(PyObject *self, PyObject *args) {
return Py_BuildValue("i", openpcd_deselect_card(handle));
}
static PyObject *pyi_openpcd_read(PyObject *self, PyObject *args) {
int ok, page;
char s[16];
ok = PyArg_ParseTuple(args, "i", &page);
openpcd_read(handle, page, s, 16);
return Py_BuildValue("s", s);
}
static PyObject *pyi_openpcd_write(PyObject *self, PyObject *args) {
int ok, page, result;
char *s = "indianindianindi";
ok = PyArg_ParseTuple(args, "is", &page, &s);
result = openpcd_write(handle, page, s, 16);
return Py_BuildValue("i", result);
}
static PyObject *pyi_set_key(PyObject *self, PyObject *args) {
int ok, key, result;
char *s = "keykeykey";
ok = PyArg_ParseTuple(args, "is", &key, &s);
result = openpcd_set_key(handle, key, s);
return Py_BuildValue("i", result);
}
static PyObject *pyi_get_card_id(PyObject *self, PyObject *args) {
unsigned int uid;
int result;
result = openpcd_get_card_id(handle, &uid);
if (result == 0)
return Py_BuildValue("I", uid);
else
return Py_BuildValue("i", result);
}
librfid/python/test.py
+24
View File
@@ -0,0 +1,24 @@
#!/usr/bin/env python
#Python bindings test file
#(C) 2007-2008 by Kushal Das <kushal@openpcd.org>
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License version 2
#as published by the Free Software Foundation
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
import pyrfid
pyrfid.open_reader()
pyrfid.select_card()
print "%08X" % (pyrfid.get_card_id())
pyrfid.deselect_card()
pyrfid.close_reader()