From d06b9bdf1f5299ceb87db2a4d7263ce88902dc7a Mon Sep 17 00:00:00 2001 From: Han Zhao Date: Tue, 12 Nov 2019 16:45:59 -0500 Subject: [PATCH 1/7] added get_software_version() --- mercury.c | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/mercury.c b/mercury.c index 317f7f4c..1e7bc666 100644 --- a/mercury.c +++ b/mercury.c @@ -1072,6 +1072,12 @@ Reader_get_model(Reader* self) return get_string(&self->reader, TMR_PARAM_VERSION_MODEL); } +static PyObject * +Reader_get_software_version(Reader* self) +{ + return get_string(&self->reader, TMR_PARAM_VERSION_SOFTWARE); +} + static PyObject * Reader_get_serial(Reader* self) { @@ -1840,6 +1846,9 @@ static PyMethodDef Reader_methods[] = { {"get_model", (PyCFunction)Reader_get_model, METH_NOARGS, "Returns the model name" }, + {"get_software_version", (PyCFunction)Reader_get_software_version, METH_NOARGS, + "Returns the software version of the reader" + }, {"get_serial", (PyCFunction)Reader_get_serial, METH_NOARGS, "Returns a serial number of the reader, the same number printed on the barcode label" }, From c4bc3631426ec3e8f7efc9fc8771037eca1016c5 Mon Sep 17 00:00:00 2001 From: Han Zhao Date: Wed, 13 Nov 2019 16:28:14 -0500 Subject: [PATCH 2/7] updated README.md --- README.md | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/README.md b/README.md index 04c72cd1..69a92c8f 100644 --- a/README.md +++ b/README.md @@ -265,6 +265,16 @@ print(reader.get_model()) M6e Nano ``` +#### reader.get_software_version() +Returns the software version of the reader hardware +For example: +```python +print(reader.get_sofware_version()) +01.0B.03.11-20.19.07.12-BL12.12.13.00 +``` +01.0B.03 is the current firmware version + + #### reader.get_serial() Returns a serial number of the reader, the same number printed on the barcode label. From 5f842d69a6f2ec3b153e5de28a78787c2ecf0180 Mon Sep 17 00:00:00 2001 From: Han Zhao Date: Tue, 9 Jun 2020 15:03:50 -0400 Subject: [PATCH 3/7] Add PyGILState_Ensure() when invoking exception callback --- mercury.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/mercury.c b/mercury.c index 1e7bc666..235c6514 100644 --- a/mercury.c +++ b/mercury.c @@ -809,7 +809,14 @@ Reader_start_reading(Reader *self, PyObject *args, PyObject *kwds) static void invoke_exception_callback(TMR_Reader *reader, const TMR_Status error, void *cookie){ Reader *self = (Reader *)cookie; - PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, error)); + if(self && self->statsCallback) + { + PyGILState_STATE gstate; + gstate = PyGILState_Ensure(); + PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, error)); + PyErr_Print(); + PyGILState_Release(gstate); + } } static void From f6d25e4980227c4941318248e3892dd2c133ad73 Mon Sep 17 00:00:00 2001 From: Han Zhao Date: Mon, 29 Jun 2020 18:41:31 -0400 Subject: [PATCH 4/7] added python exception callback handling to invoke_exception --- README.md | 12 ++++++++++++ mercury.c | 41 ++++++++++++++++++++++++++++++++++++++--- 2 files changed, 50 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 8acf9ad0..2c13d935 100644 --- a/README.md +++ b/README.md @@ -188,6 +188,18 @@ def stats_received(stats): reader.enable_stats(stats_received) ``` +### reader.enable_exception_handler(*callback*) +Provide reader exception handling +The function must be called before `reader.start_reading()`. + +For example: +```python +def exeception_handle(e): + print(e) + +reader.enable_exception_handler(exeception_handle) +``` + #### reader.start_reading(*callback*, *on_time=250*, *off_time=0*) Starts asynchronous reading. It returns immediately and begins a sequence of reads or a continuous read. The results are passed to the *callback*. diff --git a/mercury.c b/mercury.c index 20171585..bd1526cb 100644 --- a/mercury.c +++ b/mercury.c @@ -42,6 +42,7 @@ typedef struct { TMR_ReadExceptionListenerBlock exceptionListener; PyObject *readCallback; PyObject *statsCallback; + PyObject *exceptionCallback; } Reader; typedef struct { @@ -762,6 +763,28 @@ Reader_enable_stats(Reader *self, PyObject *args, PyObject *kwds) Py_RETURN_NONE; } + +static PyObject * +Reader_enable_exception_handler(Reader *self, PyObject *args, PyObject *kwds) +{ + PyObject *temp; + static char *kwlist[] = {"callback" , NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &temp)) + return NULL; + + if (!PyCallable_Check(temp)) + { + PyErr_SetString(PyExc_TypeError, "Parameter must be callable"); + return NULL; + } + + Py_XDECREF(self->exceptionCallback); + Py_XINCREF(temp); + self->exceptionCallback = temp; + Py_RETURN_NONE; +} + static PyObject * Reader_start_reading(Reader *self, PyObject *args, PyObject *kwds) { @@ -809,12 +832,21 @@ Reader_start_reading(Reader *self, PyObject *args, PyObject *kwds) static void invoke_exception_callback(TMR_Reader *reader, const TMR_Status error, void *cookie){ Reader *self = (Reader *)cookie; - if(self && self->statsCallback) + if(self && self->exceptionCallback) { + PyObject *arglist; + PyObject *result; PyGILState_STATE gstate; gstate = PyGILState_Ensure(); - PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, error)); - PyErr_Print(); + + arglist = Py_BuildValue("(s)", TMR_strerr(&self->reader, error)); + result = PyObject_CallObject(self->exceptionCallback, arglist); + if(result != NULL) + Py_DECREF(result); + else + PyErr_Print(); + Py_DECREF(arglist); + PyGILState_Release(gstate); } } @@ -1828,6 +1860,9 @@ static PyMethodDef Reader_methods[] = { {"enable_stats", (PyCFunction)Reader_enable_stats, METH_VARARGS | METH_KEYWORDS, "Provide reader stats during asynchronous tag reads" }, + {"enable_exception_handler",(PyCFunction)Reader_enable_exception_handler, METH_VARARGS | METH_KEYWORDS, + "Provide callback for reader exception handling" + }, {"start_reading", (PyCFunction)Reader_start_reading, METH_VARARGS | METH_KEYWORDS, "Start reading tags asynchronously" }, From 857339e8dfd8d48e5708b34905d0beb6996d7bd1 Mon Sep 17 00:00:00 2001 From: han Date: Thu, 11 Jun 2020 10:39:36 -0400 Subject: [PATCH 5/7] updated thingmagic sdk to latest --- Makefile | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Makefile b/Makefile index 1f144640..2e60fe77 100644 --- a/Makefile +++ b/Makefile @@ -1,5 +1,5 @@ -APIZIP ?= mercuryapi-1.31.1.36-2.zip -APIVER ?= 1.31.1.36 +APIZIP ?= mercuryapi-YEATS-1.31.4.35-1.zip +APIVER ?= 1.31.4.35 PYTHON ?= $(shell { command -v python3 || command -v python; } 2>/dev/null) .PHONY: all mercuryapi install @@ -25,4 +25,4 @@ mercuryapi-$(APIVER)/.done: $(APIZIP) touch mercuryapi-$(APIVER)/.done $(APIZIP): - curl https://www.jadaktech.com/wp-content/uploads/2019/10/$(APIZIP) -o $(APIZIP) + curl https://www.jadaktech.com/wp-content/uploads/2020/01/$(APIZIP) -o $(APIZIP) From 717d5146ed35d65d4eecb2d028a922d41d95008d Mon Sep 17 00:00:00 2001 From: Han Zhao Date: Mon, 29 Jun 2020 18:58:53 -0400 Subject: [PATCH 6/7] addded reader.get_read_state() --- README.md | 13 +++++++++++++ mercury.c | 23 +++++++++++++++++++++++ 2 files changed, 36 insertions(+) diff --git a/README.md b/README.md index 2c13d935..6d1cca11 100644 --- a/README.md +++ b/README.md @@ -292,6 +292,19 @@ print(reader.get_sofware_version()) #### reader.get_serial() Returns a serial number of the reader, the same number printed on the barcode label. +#### reader.get_read_state() +Returns the read state of the reader. + +The avaiable states are : +``` +TMR_READ_STATE_IDLE +TMR_READ_STATE_STARTING +TMR_READ_STATE_STARTED +TMR_READ_STATE_ACTIVE +TMR_READ_STATE_DONE +UNKNOWN +``` + #### reader.set_region(*region*) Controls the Region of Operation for the connected device: * *region* represents the regulatory region that the device will operate in. Supported values are: diff --git a/mercury.c b/mercury.c index bd1526cb..a2cc0513 100644 --- a/mercury.c +++ b/mercury.c @@ -1123,6 +1123,26 @@ Reader_get_serial(Reader* self) return get_string(&self->reader, TMR_PARAM_VERSION_SERIAL); } +static PyObject * +Reader_get_read_state(Reader* self) +{ + switch (self->reader.readState) + { + case TMR_READ_STATE_IDLE: + return PyUnicode_FromString("TMR_READ_STATE_IDLE"); + case TMR_READ_STATE_STARTING: + return PyUnicode_FromString("TMR_READ_STATE_STARTING"); + case TMR_READ_STATE_STARTED: + return PyUnicode_FromString("TMR_READ_STATE_STARTED"); + case TMR_READ_STATE_ACTIVE: + return PyUnicode_FromString("TMR_READ_STATE_ACTIVE"); + case TMR_READ_STATE_DONE: + return PyUnicode_FromString("TMR_READ_STATE_DONE"); + default: + return PyUnicode_FromString("UNKNOWN"); + } +} + typedef struct { const char* name; TMR_Region region; @@ -1990,6 +2010,9 @@ static PyMethodDef Reader_methods[] = { {"get_temperature", (PyCFunction)Reader_get_temperature, METH_NOARGS, "Returns the chip temperature" }, + {"get_read_state", (PyCFunction)Reader_get_read_state, METH_NOARGS, + "Returns the current state of the reader" + }, {NULL} /* Sentinel */ }; From c5a45e87ca21575e48c6a09d5567a09bf5bf1cdb Mon Sep 17 00:00:00 2001 From: hanz Date: Fri, 10 Jul 2020 03:20:12 +0900 Subject: [PATCH 7/7] added feature to print transport logs to console --- README.md | 10 ++++++++++ mercury.c | 53 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 63 insertions(+) diff --git a/README.md b/README.md index 6d1cca11..e7a7c5b1 100644 --- a/README.md +++ b/README.md @@ -188,6 +188,16 @@ def stats_received(stats): reader.enable_stats(stats_received) ``` +#### reader.enable_transportlog() +Print the transport logs logs to stdout + +The function must be called before `reader.start_reading()`. + +For example: +```python +reader.enable_transportlog() +``` + ### reader.enable_exception_handler(*callback*) Provide reader exception handling The function must be called before `reader.start_reading()`. diff --git a/mercury.c b/mercury.c index a2cc0513..c2b8617d 100644 --- a/mercury.c +++ b/mercury.c @@ -40,9 +40,11 @@ typedef struct { TMR_ReadListenerBlock readListener; TMR_StatsListenerBlock statsListener; TMR_ReadExceptionListenerBlock exceptionListener; + TMR_TransportListenerBlock transportLogListener; PyObject *readCallback; PyObject *statsCallback; PyObject *exceptionCallback; + PyObject *transportLogCallback; } Reader; typedef struct { @@ -81,6 +83,12 @@ invoke_stats_callback(TMR_Reader *reader,const TMR_Reader_StatsValues *reader_st static void invoke_exception_callback(TMR_Reader *reader, const TMR_Status ret, void *cookie); +static void +invoke_transportlog_callback_serial(bool tx, uint32_t dataLen, const uint8_t data[],uint32_t timeout, void *cookie); + +static void +invoke_transportlog_callback_string(bool tx, uint32_t dataLen, const uint8_t data[],uint32_t timeout, void *cookie); + typedef struct { const char* name; TMR_TagProtocol protocol; @@ -167,6 +175,14 @@ Reader_new(PyTypeObject *type, PyObject *args, PyObject *kwds) if ((ret = TMR_addReadExceptionListener(&self->reader, &self->exceptionListener)) != TMR_SUCCESS) goto fail; + if(TMR_READER_TYPE_SERIAL == self->reader.readerType ){ + self->transportLogListener.listener = invoke_transportlog_callback_serial; + } + else{ + self->transportLogListener.listener = invoke_transportlog_callback_string; + } + self->transportLogListener.cookie = stdout; + if ((ret = TMR_connect(&self->reader)) != TMR_SUCCESS) goto fail; @@ -764,6 +780,14 @@ Reader_enable_stats(Reader *self, PyObject *args, PyObject *kwds) } +static PyObject * +Reader_enable_transportlog(Reader *self){ + int ret; + if ((ret = TMR_addTransportListener(&self->reader, &self->transportLogListener)) != TMR_SUCCESS) + return NULL; + Py_RETURN_NONE; +} + static PyObject * Reader_enable_exception_handler(Reader *self, PyObject *args, PyObject *kwds) { @@ -829,6 +853,32 @@ Reader_start_reading(Reader *self, PyObject *args, PyObject *kwds) Py_RETURN_NONE; } + +static void +invoke_transportlog_callback_string(bool tx, uint32_t dataLen, const uint8_t data[], + uint32_t timeout, void *cookie){ + FILE *out = cookie; + fprintf(out, "%s", tx ? "Sending: " : "Received:"); + fprintf(out, "%s\n", data); +} + +static void +invoke_transportlog_callback_serial(bool tx, uint32_t dataLen, const uint8_t data[], + uint32_t timeout, void *cookie){ + FILE *out = cookie; + + uint32_t i; + printf("tranport_log\n"); + fprintf(out, "%s", tx ? "Sending: " : "Received:"); + for (i = 0; i < dataLen; i++) + { + if (i > 0 && (i & 15) == 0) + fprintf(out, "\n "); + fprintf(out, " %02x", data[i]); + } + fprintf(out, "\n"); +} + static void invoke_exception_callback(TMR_Reader *reader, const TMR_Status error, void *cookie){ Reader *self = (Reader *)cookie; @@ -1883,6 +1933,9 @@ static PyMethodDef Reader_methods[] = { {"enable_exception_handler",(PyCFunction)Reader_enable_exception_handler, METH_VARARGS | METH_KEYWORDS, "Provide callback for reader exception handling" }, + {"enable_transportlog",(PyCFunction)Reader_enable_transportlog, METH_VARARGS | METH_KEYWORDS, + "Provide callback for reader transport logs" + }, {"start_reading", (PyCFunction)Reader_start_reading, METH_VARARGS | METH_KEYWORDS, "Start reading tags asynchronously" },