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;
TMR_ReadListenerBlock rlb;
TMR_ReadExceptionListenerBlock reb;
#if USE_TRANSPORT_LISTENER
TMR_TransportListenerBlock tb;
#endif
if (argc < 2)
{
errx(1, "Please provide reader URL, such as:\n"
"tmr:///com4\n"
"tmr://my-reader.example.com\n");
}
rp = &r;
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");
}
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");
{
TMR_ReadPlan plan;
TMR_TagFilter filter;
TMR_ISO180006B_Delimiter delimiter;
uint8_t wordData[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };
/* Set the Delimiter to 1 */
delimiter = TMR_ISO180006B_Delimiter1;
ret = TMR_paramSet(rp, TMR_PARAM_ISO180006B_DELIMITER, &delimiter);
checkerr(rp, ret, 1, "setting the delimiter");
/* Read Plan */
TMR_RP_init_simple(&plan, 0, NULL, TMR_TAG_PROTOCOL_ISO180006B, 1000);
TMR_TF_init_ISO180006B_select(&filter, false, TMR_ISO180006B_SELECT_OP_NOT_EQUALS, 0, 0xff, wordData);
/* Commit read plan */
ret = TMR_RP_set_filter(&plan, &filter);
checkerr(rp, ret, 1, "setting filter to the read plan");
ret = TMR_paramSet(rp, TMR_PARAM_READ_PLAN, &plan);
checkerr(rp, ret, 1, "setting read plan");
}
ret = TMR_startReading(rp);
checkerr(rp, ret, 1, "starting reading");
#ifndef WIN32
sleep(5);
#else
Sleep(5000);
#endif
ret = TMR_stopReading(rp);
checkerr(rp, ret, 1, "stopping reading");
TMR_destroy(rp);
return 0;
#endif /* TMR_ENABLE_BACKGROUND_READS */
}
int main(int argc, char *argv[])
{
TMR_Reader r, *rp;
TMR_Status ret;
TMR_Region region;
#if USE_TRANSPORT_LISTENER
TMR_TransportListenerBlock tb;
#endif
if (argc < 2)
{
errx(1, "Please provide reader URL, such as:\n"
"tmr:///com4\n"
"tmr://my-reader.example.com\n");
}
rp = &r;
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");
}
{
TMR_ReadPlan simpleReadPlan, multiReadPlan;
TMR_ReadPlan subplans[5];
TMR_ReadPlan* subplanPtrs[5];
TMR_TagProtocolList value;
TMR_TagProtocol valueList[32];
int subplanCount = 0;
int j;
TMR_SR_GEN2_Q qValue;
uint8_t antenna[] = {1};
uint32_t tagCount = 1;
/* Initial test setup */
/* Set the Q value as per the tag population */
qValue.type = TMR_SR_GEN2_Q_STATIC;
qValue.u.staticQ.initialQ = 0;
ret = TMR_paramSet(rp, TMR_PARAM_GEN2_Q, &qValue);
checkerr(rp, ret, 1, "setting the Q Value");
/* The simple read plan */
TMR_RP_init_simple (&simpleReadPlan, 1, antenna, TMR_TAG_PROTOCOL_GEN2, 1000);
/* Stop N trigger */
TMR_RP_set_stopTrigger (&simpleReadPlan, tagCount);
/* The multi read plan */
{
value.max = 32;
value.list = valueList;
/* Berfore setting the readplen, we must get list of supported protocols */
ret = TMR_paramGet(rp, TMR_PARAM_VERSION_SUPPORTEDPROTOCOLS, &value);
checkerr(rp, ret, 1, "Getting the supported protocols");
{
ret = TMR_RP_init_simple(&subplans[subplanCount], 1, antenna,TMR_TAG_PROTOCOL_GEN2 , 1000);
TMR_RP_set_stopTrigger (&subplans[subplanCount], tagCount);
subplanCount++;
ret = TMR_RP_init_simple(&subplans[subplanCount], 1, antenna, TMR_TAG_PROTOCOL_ISO180006B, 1000);
TMR_RP_set_stopTrigger (&subplans[subplanCount], tagCount);
subplanCount++;
}
for (j = 0; j < subplanCount; j++)
{
subplanPtrs[j] = &subplans[j];
}
TMR_RP_init_multi(&multiReadPlan, subplanPtrs, subplanCount, 0);
}
/* Set the read plan */
ret = TMR_paramSet(rp, TMR_PARAM_READ_PLAN, &simpleReadPlan);
//enable this for multi read plan
//ret = TMR_paramSet(rp, TMR_PARAM_READ_PLAN, &multiReadPlan);
checkerr(rp, ret, 1, "setting read plan");
/* The sync read */
{
ret = TMR_read(rp, 1000, NULL);
checkerr(rp, ret, 1, "reading tags");
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("EPC:%s\n", epcStr);
}
}
}
TMR_destroy(rp);
return 0;
}
int RFIDstartReader(const char* deviceURI)
{
readers = realloc(readers, (readerCount + 1) * sizeof(TMR_Reader*));
TMR_Reader* pr = malloc(sizeof(TMR_Reader));
readers[readerCount] = pr;
plan = realloc(plan, (readerCount + 1) * sizeof(TMR_ReadPlan*));
TMR_ReadPlan* prp = malloc(sizeof(TMR_ReadPlan));
plan[readerCount] = prp;
rlb = realloc(rlb, (readerCount + 1) * sizeof(TMR_ReadListenerBlock*));
TMR_ReadListenerBlock* prlb = malloc(sizeof(TMR_ReadListenerBlock));
rlb[readerCount] = prlb;
reb = realloc(reb, (readerCount + 1) * sizeof(TMR_ReadExceptionListenerBlock*));
TMR_ReadExceptionListenerBlock* preb = malloc(sizeof(TMR_ReadExceptionListenerBlock));
reb[readerCount] = preb;
region = realloc(region, (readerCount + 1) * sizeof(TMR_Region*));
TMR_Region* preg = malloc(sizeof(TMR_Region));
region[readerCount] = preg;
status = realloc(status, (readerCount + 1) * sizeof(TMR_Status*));
TMR_Status* pstat = malloc(sizeof(TMR_Status));
status[readerCount] = pstat;
model = realloc(model, (readerCount + 1) * sizeof(TMR_String*));
TMR_String* pstr = malloc(sizeof(TMR_String));
model[readerCount] = pstr;
if(checkError(TMR_create(readers[readerCount], deviceURI), "Creating reader"))
{
return -1;
}
if(checkError(TMR_connect(readers[readerCount]), "Connecting to reader"))
{
return -1;
}
*(region[readerCount]) = TMR_REGION_NONE;
if(checkError(TMR_paramGet(readers[readerCount], TMR_PARAM_REGION_ID, region[readerCount]), "Getting Saved Region"))
{
return -1;
}
if(*(region[readerCount]) == TMR_REGION_NONE)
{
printf("No saved regions\n");
TMR_RegionList regions;
TMR_Region _regionStore[32];
regions.list = _regionStore;
regions.max = sizeof(_regionStore)/sizeof(_regionStore[0]);
regions.len = 0;
if(checkError(TMR_paramGet(readers[readerCount], TMR_PARAM_REGION_SUPPORTEDREGIONS, ®ions), "Getting List of Regions"))
{
return -1;
}
if(regions.len < 1)
{
printf("Reader doesn't support any regions\n");
return -1;
}
*(region[readerCount]) = regions.list[0];
if(checkError(TMR_paramSet(readers[readerCount], TMR_PARAM_REGION_ID, &*(region[readerCount])), "Setting region"))
{
return -1;
}
}
if(checkError(TMR_RP_init_simple(plan[readerCount], 0x0, NULL, TMR_TAG_PROTOCOL_GEN2, 1000), "Initialising read plan"))
{
return -1;
}
if(checkError(TMR_paramSet(readers[readerCount], TMR_PARAM_READ_PLAN, plan[readerCount]), "Setting Read Plan"))
{
return -1;
}
rlb[readerCount]->listener = tagCallback;
rlb[readerCount]->cookie = NULL;
reb[readerCount]->listener = exceptionCallback;
reb[readerCount]->cookie = NULL;
if(checkError(TMR_addReadListener(readers[readerCount], rlb[readerCount]), "Adding read listener"))
{
return -1;
}
if(checkError(TMR_addReadExceptionListener(readers[readerCount], reb[readerCount]), "Adding Exception Listener"))
{
return -1;
}
if(checkError(TMR_startReading(readers[readerCount]), "Starting reader"))
{
return -1;
}
uniqueReaderInstance++;
return (uniqueReaderInstance - 1);
}
