static PyObject *
Reader_read(Reader *self, PyObject *args, PyObject *kwds)
{
int timeout = 500;
PyObject *list;
TMR_Status ret;
static char *kwlist[] = {"timeout", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|i", kwlist, &timeout))
return NULL;
Py_BEGIN_ALLOW_THREADS
ret = TMR_read(&self->reader, timeout, NULL);
Py_END_ALLOW_THREADS
/* In case of TAG ID Buffer Full, extract the tags present in buffer. */
if (ret != TMR_SUCCESS && ret != TMR_ERROR_TAG_ID_BUFFER_FULL)
{
PyErr_SetString(PyExc_RuntimeError, TMR_strerr(&self->reader, ret));
return NULL;
}
/* create empty list */
list = PyList_New(0);
while (TMR_hasMoreTags(&self->reader) == TMR_SUCCESS)
{
TagReadData *tag;
uint8_t dataBuf1[MAX_DATA_AREA];
uint8_t dataBuf2[MAX_DATA_AREA];
uint8_t dataBuf3[MAX_DATA_AREA];
uint8_t dataBuf4[MAX_DATA_AREA];
tag = PyObject_New(TagReadData, &TagReadDataType);
TMR_TRD_init(&tag->data);
TMR_TRD_MEMBANK_init_data(&tag->data.epcMemData, MAX_DATA_AREA, dataBuf1);
TMR_TRD_MEMBANK_init_data(&tag->data.tidMemData, MAX_DATA_AREA, dataBuf2);
TMR_TRD_MEMBANK_init_data(&tag->data.userMemData, MAX_DATA_AREA, dataBuf3);
TMR_TRD_MEMBANK_init_data(&tag->data.reservedMemData, MAX_DATA_AREA, dataBuf4);
if ((ret = TMR_getNextTag(&self->reader, &tag->data)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_RuntimeError, TMR_strerr(&self->reader, ret));
return NULL;
}
tag->epcMemData = PyByteArray_FromUInt8List(&tag->data.epcMemData);
tag->tidMemData = PyByteArray_FromUInt8List(&tag->data.tidMemData);
tag->userMemData = PyByteArray_FromUInt8List(&tag->data.userMemData);
tag->reservedMemData = PyByteArray_FromUInt8List(&tag->data.reservedMemData);
PyList_Append(list, (PyObject *)tag);
Py_XDECREF(tag);
}
return list;
}
static PyObject *
Reader_set_region(Reader *self, PyObject *args)
{
char *s;
TMR_Region region;
TMR_Status ret;
if (!PyArg_ParseTuple(args, "s", &s))
return NULL;
if ((region = str2region(s)) == TMR_REGION_NONE)
{
PyErr_SetString(PyExc_TypeError, "Unknown region");
return NULL;
}
if ((ret = TMR_paramSet(&self->reader, TMR_PARAM_REGION_ID, ®ion)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, ret));
return NULL;
}
/* Do something interesting here. */
Py_RETURN_NONE;
}
void checkerr(TMR_Reader* rp, TMR_Status ret, int exitval, const char *msg)
{
if (TMR_SUCCESS != ret)
{
errx(exitval, "Error %s: %s\n", msg, TMR_strerr(rp, ret));
}
}
static PyObject *
Reader_get_supported_regions(Reader* self)
{
int i;
TMR_RegionList regions;
TMR_Region regionStore[32];
TMR_Status ret;
PyObject *list;
regions.list = regionStore;
regions.max = sizeof(regionStore)/sizeof(regionStore[0]);
regions.len = 0;
if ((ret = TMR_paramGet(&self->reader, TMR_PARAM_REGION_SUPPORTEDREGIONS, ®ions)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, ret));
return NULL;
}
/* create empty list */
list = PyList_New(0);
for (i = 0; i < regions.len; i++)
{
const char* name = region2str(regions.list[i]);
if (name != NULL)
{
PyObject *sname = PyUnicode_FromString(name);
PyList_Append(list, sname);
Py_DECREF(sname);
}
}
return list;
}
static PyObject *
Reader_set_antenna_portswitchgpos(Reader *self, PyObject *args)
{
TMR_Status ret;
PyObject *gpos;
TMR_uint8List gpo_list;
uint8_t value_list[MAX_GPIO_COUNT];
uint8_t gpo_count;
uint8_t i;
if (!PyArg_ParseTuple(args, "O", &gpos))
return NULL;
if ((gpo_count = PyList_Size(gpos)) > MAX_GPIO_COUNT)
{
PyErr_SetString(PyExc_TypeError, "Too many gpos");
return NULL;
}
gpo_list.len = gpo_count;
gpo_list.list = value_list;
gpo_list.max = numberof(value_list);
for (i = 0; i < gpo_list.len && i < gpo_list.max; i++)
{
value_list[i] = (uint8_t) PyLong_AsLong(PyList_GetItem(gpos, i));
}
if ((ret = TMR_paramSet(&self->reader, TMR_PARAM_ANTENNA_PORTSWITCHGPOS, &gpo_list)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, ret));
return NULL;
}
Py_RETURN_NONE;
}
static PyObject *
Reader_start_reading(Reader *self, PyObject *args, PyObject *kwds)
{
PyObject *temp;
int onTime = 250;
int offTime = 0;
TMR_Status ret;
static char *kwlist[] = {"callback", "on_time", "off_time", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|ii", kwlist, &temp, &onTime, &offTime))
return NULL;
if (!PyCallable_Check(temp))
{
PyErr_SetString(PyExc_TypeError, "Parameter must be callable");
return NULL;
}
if ((ret = TMR_paramSet(&self->reader, TMR_PARAM_READ_ASYNCONTIME, &onTime)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, ret));
return NULL;
}
if ((ret = TMR_paramSet(&self->reader, TMR_PARAM_READ_ASYNCOFFTIME, &offTime)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, ret));
return NULL;
}
Py_XDECREF(self->readCallback);
Py_XINCREF(temp);
self->readCallback = temp;
if ((ret = TMR_startReading(&self->reader)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_RuntimeError, TMR_strerr(&self->reader, ret));
return NULL;
}
Py_RETURN_NONE;
}
static PyObject *
Reader_get_power_range(Reader *self)
{
int lim_power;
TMR_Status ret;
PyObject *powers;
powers = PyTuple_New(2);
if ((ret = TMR_paramGet(&self->reader, TMR_PARAM_RADIO_POWERMIN, &lim_power)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, ret));
return NULL;
}
PyTuple_SetItem(powers, 0, PyLong_FromLong((long) lim_power));
if ((ret = TMR_paramGet(&self->reader, TMR_PARAM_RADIO_POWERMAX, &lim_power)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, ret));
return NULL;
}
PyTuple_SetItem(powers, 1, PyLong_FromLong((long) lim_power));
return powers;
}
static PyObject *
Reader_get_gen2_blf(Reader* self)
{
TMR_Status ret;
TMR_GEN2_LinkFrequency blf_val;
if ((ret = TMR_paramGet(&self->reader, TMR_PARAM_GEN2_BLF, &blf_val)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, ret));
return NULL;
}
return PyLong_FromLong(blf_val);
}
static PyObject *
Reader_get_gen2_session(Reader* self)
{
TMR_Status ret;
TMR_GEN2_Session session_val;
if ((ret = TMR_paramGet(&self->reader, TMR_PARAM_GEN2_SESSION, &session_val)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, ret));
return NULL;
}
return PyLong_FromLong(session_val);
}
static PyObject *
Reader_get_gen2_tari(Reader* self)
{
TMR_Status ret;
TMR_GEN2_Tari tari_val;
if ((ret = TMR_paramGet(&self->reader, TMR_PARAM_GEN2_TARI, &tari_val)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, ret));
return NULL;
}
return PyLong_FromLong(tari_val);
}
static PyObject *
Reader_set_gen2_tari(Reader* self, PyObject *args)
{
TMR_Status ret;
TMR_GEN2_Tari tari_val;
if (!PyArg_ParseTuple(args, "i", &tari_val))
return NULL;
if ((ret = TMR_paramSet(&self->reader, TMR_PARAM_GEN2_TARI, &tari_val)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, ret));
return NULL;
}
return PyLong_FromLong(tari_val);
}
static PyObject *
Reader_get_model(Reader* self)
{
TMR_String model;
char str[64];
TMR_Status ret;
model.value = str;
model.max = sizeof(str);
if ((ret = TMR_paramGet(&self->reader, TMR_PARAM_VERSION_MODEL, &model)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, ret));
return NULL;
}
return PyUnicode_FromString(model.value);
}
static PyObject *
Reader_get_gen2_q(Reader* self)
{
TMR_Status ret;
TMR_SR_GEN2_Q model;
PyObject *q_value;
if ((ret = TMR_paramGet(&self->reader, TMR_PARAM_GEN2_Q, &model)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, ret));
return NULL;
}
q_value = PyTuple_New(2);
PyTuple_SetItem(q_value, 0, PyLong_FromLong((long) model.type));
PyTuple_SetItem(q_value, 1, PyLong_FromLong((long) model.u.staticQ.initialQ));
return q_value;
}
static PyObject *
Reader_get_write_powers(Reader *self)
{
int row;
TMR_Status ret;
PyObject *antenna_power;
PyObject *antenna_powers;
antenna_powers = PyList_New(0);
TMR_PortValueList ant_pow_list;
TMR_PortValue pow_value_list[MAX_ANTENNA_COUNT];
ant_pow_list.list = pow_value_list;
ant_pow_list.max = numberof(pow_value_list);
TMR_uint8List port_list;
uint8_t port_value_list[MAX_ANTENNA_COUNT];
port_list.list = port_value_list;
port_list.max = numberof(port_value_list);
if ((ret = TMR_paramGet(&self->reader, TMR_PARAM_ANTENNA_PORTLIST, &port_list)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_TypeError, "Error getting antennas");
return NULL;
}
if ((ret = TMR_paramGet(&self->reader, TMR_PARAM_RADIO_PORTWRITEPOWERLIST, &ant_pow_list)) != TMR_SUCCESS)
{
PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, ret));
return NULL;
}
for (row = 0; row < port_list.len; row++)
{
antenna_power = PyTuple_New(2);
PyTuple_SetItem(antenna_power, 0, PyLong_FromLong((long) ant_pow_list.list[row].port));
PyTuple_SetItem(antenna_power, 1, PyLong_FromLong((long) ant_pow_list.list[row].value));
PyList_Append(antenna_powers, antenna_power);
}
return antenna_powers;
}
static PyObject *
Reader_stop_reading(Reader* self)
{
PyObject *temp = self->readCallback;
TMR_Status ret;
/* avoid deadlock as calling stopReading will invoke the callback */
self->readCallback = NULL;
if ((ret = TMR_stopReading(&self->reader)) != TMR_SUCCESS)
{
self->readCallback = temp; /* revert back as the function will fail */
PyErr_SetString(PyExc_RuntimeError, TMR_strerr(&self->reader, ret));
return NULL;
}
Py_XDECREF(temp);
Py_RETURN_NONE;
}
static PyObject *
Reader_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
Reader *self;
char *deviceUri;
int baudRate = 0;
TMR_Status ret;
static char *kwlist[] = {"uri", "baudrate", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|i", kwlist, &deviceUri, &baudRate))
return NULL;
self = (Reader *)type->tp_alloc(type, 0);
if (self == NULL)
return NULL;
if ((ret = TMR_create(&self->reader, deviceUri)) != TMR_SUCCESS)
goto fail;
if (baudRate > 0)
{
if ((ret = TMR_paramSet(&self->reader, TMR_PARAM_BAUDRATE, &baudRate)) != TMR_SUCCESS)
goto fail;
}
/* install the callback wrapper for asynchronous reading */
self->readListener.listener = invoke_read_callback;
self->readListener.cookie = self;
if ((ret = TMR_addReadListener(&self->reader, &self->readListener)) != TMR_SUCCESS)
goto fail;
if ((ret = TMR_connect(&self->reader)) != TMR_SUCCESS)
goto fail;
return (PyObject *)self;
fail:
PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, ret));
Py_TYPE(self)->tp_free((PyObject*)self);
return NULL;
}
const char *
TMR_strerror(TMR_Status status)
{
return TMR_strerr(NULL, status);
}
void
exceptionCallback(TMR_Reader *reader, TMR_Status error, void *cookie)
{
fprintf(stdout, "Error:%s\n", TMR_strerr(reader, error));
}
static PyObject *
Reader_set_read_plan(Reader *self, PyObject *args, PyObject *kwds)
{
PyObject *list;
char *s;
TMR_TagProtocol protocol;
TMR_ReadPlan plan;
TMR_Status ret;
int i;
uint8_t ant_count;
PyObject *bank = NULL;
int readPower = 0;
static char *kwlist[] = {"antennas", "protocol", "bank", "read_power", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!s|Oi", kwlist, &PyList_Type, &list, &s, &bank, &readPower))
return NULL;
if ((protocol = str2protocol(s)) == TMR_TAG_PROTOCOL_NONE)
{
PyErr_SetString(PyExc_TypeError, "unknown protocol");
return NULL;
}
if ((ant_count = PyList_Size(list)) > MAX_ANTENNA_COUNT)
{
PyErr_SetString(PyExc_TypeError, "Too many antennas");
return NULL;
}
for (i = 0; i < ant_count; i++)
{
uint8_t num;
if ((num = as_uint8(PyList_GetItem(list, i))) == 255)
{
PyErr_SetString(PyExc_TypeError, "expecting a list of 8-bit integers");
return NULL;
}
self->antennas[i] = num;
}
if ((ret = TMR_RP_init_simple(&plan, ant_count, self->antennas, protocol, 1000)) != TMR_SUCCESS)
goto fail;
if (bank != NULL)
{
int op = 0;
if(PyList_Check(bank))
{
for (i = 0; i < PyList_Size(bank); i++)
{
int op2;
if ((op2 = str2bank(PyList_GetItem(bank, i))) == 0)
return NULL;
op |= op2;
}
}
else
{
if ((op = str2bank(bank)) == 0)
return NULL;
}
if ((ret = TMR_TagOp_init_GEN2_ReadData(&self->tagop, op, 0, 0)) != TMR_SUCCESS)
goto fail;
if ((ret = TMR_RP_set_tagop(&plan, &self->tagop)) != TMR_SUCCESS)
goto fail;
}
if ((ret = TMR_paramSet(&self->reader, TMR_PARAM_READ_PLAN, &plan)) != TMR_SUCCESS)
goto fail;
if (readPower > 0)
{
if ((ret = TMR_paramSet(&self->reader, TMR_PARAM_RADIO_READPOWER, &readPower)) != TMR_SUCCESS)
goto fail;
}
Py_RETURN_NONE;
fail:
PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, ret));
return NULL;
}
int main(int argc, char *argv[])
{
#ifndef TMR_ENABLE_BACKGROUND_READS
errx(1, "This sample requires background read functionality.\n"
"Please enable TMR_ENABLE_BACKGROUND_READS in tm_config.h\n"
"to run this codelet\n");
return -1;
#else
TMR_Reader r, *rp;
TMR_Status ret;
TMR_Region region;
#if USE_TRANSPORT_LISTENER
TMR_TransportListenerBlock tb;
#endif
TMR_ReadListenerBlock rlb;
TMR_ReadExceptionListenerBlock reb;
if (argc < 2)
{
errx(1, "Please provide reader URL, such as:\n"
"customschemename://readerIP:portname\n");
}
rp = &r;
/**
* Add the custom transport scheme before calling TMR_create().
* This can be done by using C API helper function TMR_setSerialTransport().
* It accepts two arguments. scheme and nativeInit.
* scheme: the custom transport scheme name. For demonstration using scheme as "tcp".
* nativeInit: reference to the transport factory init function.
*/
ret = TMR_setSerialTransport("tcp", &TMR_SR_SerialTransportTcpNativeInit);
checkerr(rp, ret, 1, "adding the custom transport scheme");
ret = TMR_create(rp, argv[1]);
checkerr(rp, ret, 1, "creating reader");
#if USE_TRANSPORT_LISTENER
if (TMR_READER_TYPE_SERIAL == rp->readerType)
{
tb.listener = serialPrinter;
}
else
{
tb.listener = stringPrinter;
}
tb.cookie = stdout;
TMR_addTransportListener(rp, &tb);
#endif
ret = TMR_connect(rp);
checkerr(rp, ret, 1, "connecting reader");
region = TMR_REGION_NONE;
ret = TMR_paramGet(rp, TMR_PARAM_REGION_ID, ®ion);
checkerr(rp, ret, 1, "getting region");
if (TMR_REGION_NONE == region)
{
TMR_RegionList regions;
TMR_Region _regionStore[32];
regions.list = _regionStore;
regions.max = sizeof(_regionStore)/sizeof(_regionStore[0]);
regions.len = 0;
ret = TMR_paramGet(rp, TMR_PARAM_REGION_SUPPORTEDREGIONS, ®ions);
checkerr(rp, ret, __LINE__, "getting supported regions");
if (regions.len < 1)
{
checkerr(rp, TMR_ERROR_INVALID_REGION, __LINE__, "Reader doesn't supportany regions");
}
region = regions.list[0];
ret = TMR_paramSet(rp, TMR_PARAM_REGION_ID, ®ion);
checkerr(rp, ret, 1, "setting region");
}
{
/* Initiate a sync read */
printf("\nDoing a sync read for 1sec duration\n");
ret = TMR_read(rp, 1000, NULL);
if (TMR_SUCCESS != ret)
{
fprintf(stderr, "Error reading tags: %s\n", TMR_strerr(rp, ret));
/* Don't exit, tags might still have been read before the error occurred. */
}
while (TMR_SUCCESS == TMR_hasMoreTags(rp))
{
TMR_TagReadData trd;
char epcStr[128];
ret = TMR_getNextTag(rp, &trd);
checkerr(rp, ret, 1, "fetching tag");
TMR_bytesToHex(trd.tag.epc, trd.tag.epcByteCount, epcStr);
printf("Background read: %s Protocol:%0x \n", epcStr, trd.tag.protocol);
}
}
{
/* Initiate an async read */
printf("\nDoing an async read for 1sec duration\n");
rlb.listener = callback;
rlb.cookie = NULL;
reb.listener = exceptionCallback;
reb.cookie = NULL;
ret = TMR_addReadListener(rp, &rlb);
checkerr(rp, ret, 1, "adding read listener");
ret = TMR_addReadExceptionListener(rp, &reb);
checkerr(rp, ret, 1, "adding exception listener");
ret = TMR_startReading(rp);
checkerr(rp, ret, 1, "starting reading");
tmr_sleep(1000);
ret = TMR_stopReading(rp);
checkerr(rp, ret, 1, "stopping reading");
}
TMR_destroy(rp);
return 0;
#endif /* TMR_ENABLE_BACKGROUND_READS */
}
static PyObject *
Reader_set_write_powers(Reader *self, PyObject *args, PyObject *kwds)
{
int length;
TMR_Status ret;
uint8_t ant_count, pow_count;
PyObject *power_list, *antenna_list;
static char *kwlist[] = {"antennas", "powers", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!O!", kwlist, &PyList_Type, &antenna_list, &PyList_Type, &power_list))
return NULL;
if ((ant_count = PyList_Size(antenna_list)) > MAX_ANTENNA_COUNT)
{
PyErr_SetString(PyExc_TypeError, "Too many antennas");
return NULL;
}
if ((pow_count = PyList_Size(power_list)) > MAX_ANTENNA_COUNT)
{
PyErr_SetString(PyExc_TypeError, "Too many powers");
return NULL;
}
if (pow_count != ant_count)
{
PyErr_SetString(PyExc_TypeError, "Number of antennas and powers not matching");
return NULL;
}
length = (int) ant_count;
int row;
int power;
int antenna;
TMR_PortValueList ant_pow_list;
TMR_PortValue value_list[MAX_ANTENNA_COUNT];
ant_pow_list.len = length;
ant_pow_list.max = numberof(value_list);
ant_pow_list.list = value_list;
for (row = 0; row < length; row++)
{
power = (int) PyLong_AsLong(PyList_GetItem(power_list, row));
antenna = (int) PyLong_AsLong(PyList_GetItem(antenna_list, row));
if ((ant_pow_list.list[row].port = antenna) == 255)
{
PyErr_SetString(PyExc_TypeError, "antennas expecting a list of integers");
return NULL;
}
if ((ant_pow_list.list[row].value = power) == 255)
{
PyErr_SetString(PyExc_TypeError, "powers expecting a list of integers");
return NULL;
}
}
if (length > 0)
{
if ((ret = TMR_paramSet(&self->reader, TMR_PARAM_RADIO_PORTWRITEPOWERLIST, &ant_pow_list)) != TMR_SUCCESS)
goto fail;
}
return Reader_get_write_powers(self);
fail:
PyErr_SetString(PyExc_TypeError, TMR_strerr(&self->reader, ret));
return NULL;
}
