RifidiWiki - User contributions [en]

ThingMagic

2011-11-24T19:21:40Z

StevenCollins:

[[Category:developerDoc]][[Category:EmulatorDoc]][[Category:userDoc]]

==Introduction==

;Model Number:
4
;Network Protocol:
SQL like protocol that may be wrapped in ssh, web interface, RCP, and Linux shell login.
;Communication:
10/100 BaseT Ethernet – RJ45
;Antennas:
4 read points (4 transmit points, 4 receive points)
;General Purpose I/O:
(To Do)

==Basis of Virtual Reader==
The reader accepts SQL style protocol and returns the appropriate information.

===Documentation===

===Client Tools===
Telnet, SSH clients, and Tag Centric

==Reader Design==
This section will give a brief overview of how the hardware reader operates for the purposes of emulation.
Here is the architecture for the emulator: [[ThingMagic/Emulator_Architecture]] [Deprecated]
===Communication===

====Protocols====
The main method for communicating with the reader is via TCP, TCP+SSH on port 8080, web interface, and RCP.

===Memory Model===
The memory model is like a state based database.
===Getting Tags===
Getting tags is fairly simple just execute:
<pre><nowiki>
telnet [reader ip address] 8080
</nowiki></pre>
Then type:
<pre><nowiki>
select id from tag_id set time_out=[milliseconds];
</nowiki></pre>
Note: the semicolon at the end of each command is necessary.
 
One can also return multiple items:
<pre><nowiki>
select id, protocol_id from tag_id set time_out=[milliseconds];
</nowiki></pre>

Also add filters or conditionals:
<pre><nowiki>
select id from tag_id where [condition or filter] set time_out=[milliseconds];
</nowiki></pre>
Note: The where clause only works on tag_id or tag_data tables. Only '''protocol_id''' can have a string in the where clause.

In addition more than one statement can be put on more than one line.
<pre><nowiki>
select id from tag_id set time_out=[milliseconds]; select protocol from tag_id set time_out=[milliseconds];
</nowiki></pre> 

Tag Centric reads tags in the following [http://www.shoppharmacycounter.com/t-Adipex-Medicine.aspx what is adipex] manner:
<pre><nowiki>
select id,read_count from tag_id WHERE (protocol_id='EPC0' and protocol_id='EPC1' and protocol_id='GEN2') set time_out=200;
</nowiki></pre>
From this, one can tell if two conditions conjoined with 'AND' use the same column name, it counts as a logical 'OR'.
====Timer====

====Autonomous Mode and Cursors====
First create a cursor:
<pre><nowiki>
declare cursor_name cursor for select id, protocol_id from tag_table;
</nowiki></pre>

To use the cursor just once...
<pre><nowiki>
fetch cursor_name;
</nowiki></pre>
One may add more cursors to the fetch list by separating them by commas.

To turn on auto mode:
<pre><nowiki>
set auto cursorlist = ON;
</nowiki></pre>

To add in additional delay between one tag read [http://www.supplementstoweightloss.com/t-dietpills.aspx diet supplements] operation and another:
<pre><nowiki>
set auto cursorlist = on, repeat = 500;
</nowiki></pre>
NOTE: 500 is the minimum time between the start of one tag read operation to the start of another. This ''includes'' any time_out value in the select command used for the cursor.

To set the delay between the end of the cursor list to the beginning of it repeating again, use:
<pre><nowiki>
SET repeat = 1000;
</nowiki></pre>

To turn auto mode off:
<pre><nowiki>
SET auto = OFF;
</nowiki></pre>
NOTE: Do not try to use any other command while auto mode is on; it may cause an ''undesirable undefined'' operation.

To delete a cursor:
<pre><nowiki>
close cursor_name;
</nowiki></pre>
NOTE: only one cursor can be close/deleted at a time, and no cursor lists are allowed in the syntax of this command.

====Reset====
To reset the reader as if there where no cursors defined and no tags read:
<pre><nowiki>
reset;
</nowiki></pre>

===Login===
By SSH log in.

===RQL Schema===
{| class="wikitable" border="1"
|+ tag_id
! Read/Write !! Field !! Type
|-
|R || protocol_id || Int
|-
|R || antenna_id || Int
|-
|R || read_count || Int
|-
| R/W || id || Hex String
|-
|W || killed || Int
|-
|W || password || Hex String
|-
|R || locked || Int
|-
|R || frequency || Int
|-
|R || dspmicros || Int
|-
|R || timestamp || String
|-
|}
 
{| class="wikitable" border="1"
|+ tag_data
! Read/Write !! Field !! Type
|-
|R || id || Hex String
|-
|R/W || block number || Int
|-
|R/W || data || Hex String
|-
|R || locked || Int
|-
|}
 
{| class="wikitable" border="1"
|+ settings
! Read/Write !! Field !! Type
|-
|R || current_time || String
|-
|R || version || String
|-
|R || supported_protocols || String
|-
|}
 
{| class="wikitable" border="1"
|+ io
!Read/Write !! Field !! Type
|-
|R/W || data || Hex String
|-
|}
 
{| class="wikitable" border="1"
|+ saved_settings
!Read/Write !! Field !! Type
|-
|R/W || hostname || String
|-
|R/W || iface || String
|-
|R/W || dhcpcd || String
|-
|R/W || ip_address || String
|-
|R/W || netmask || String
|-
|R/W || gateway || String
|-
|R/W || ntp_servers || String
|-
|R/W || 1tx_power || String
|-
|R/W || uhf_power_centidbm || String
|-
|R/W || epc1_id_length || String
|-
|R/W || primary_dns || String
|-
|R/W || secondary_dns || String
|-
|R/W || domain_name || String
|-
|R/W || reader_description || String
|-
|R/W || reader_role || String
|-
|R/W || ant1_readpoint_descr || String
|-
|R/W || ant2_readpoint_descr || String
|-
|R/W || ant3_readpoint_descr || String
|-
|R/W || ant4_readpoint_descr || String
|-
|}

==Supported Features==
All tables except tag_data are supported. Where clause only works on tag_id and tag_data on the real reader. Automode is working.

Only no-complex (simple) where clauses are supported now only for the '''select''' command, like:
<pre><nowiki>
select id,read_count from tag_id WHERE protocol_id='GEN2';
</nowiki></pre>

Adding and removing cursors works. Also automode works (see above examples).
==Unsupported Features & Bugs==
Tag_data table and compound conditions are not supported. ThingMagic, Mercury 5 reader RQL features are also not supported. Login by ssh is not supported. Also the time_out feature for reading tags is not supported yet. Complex where clauses are not currently supported but may be in a future release.

==Features that might never be supported==
Linux shell access to reader. This is fairly complex and require to emulate the entire hardware infrastructure of the reader and an ARM possessor. Also the web and RCP interface might be developed at a later time.

Symbol XR440

2011-11-24T19:20:23Z

StevenCollins:

[[Category:developerDoc]][[Category:EmulatorDoc]][[Category:userDoc]]

==Introduction==
The XR440 is manufactured by Motorola. It is a general purpose reader that can read Class 1 Gen 2 tags.

;Model Number:
XR440
;Network Protocol:
Bit Encoded Messages over TCP & HTTP over TCP
;Communication:
10/100 BaseT Ethernet – RJ45
;Antennas:
4 read points (4 transmit points, 4 receive points)
;General Purpose I/O:
N/A
==Basis of Virtual Reader==
The implementation of the virtual reader is based on the testing of an actual hardware reader. Testing was done using wireshark to capture the client-reader communication. This input output was then emulated.
===Documentation===
*[http://support.symbol.com/support/browse.do?WidgetName=BROWSE_PRODUCT&TaxoName=SG_SupportGoals&BROWSE_PRODUCT.isProductTaxonomy=true&BROWSE_PRODUCT.NodeId=SG_XR440_1_2&BROWSE_PRODUCT.thisPageUrl=%2Fproduct%2Fproducts.do&id=m4&BROWSE_PRODUCT.TaxoName=SG_SupportGoals&NodeType=leaf&NodeName=XR440&document=DT_PRODUCTMANUALS_1_1&BROWSE_PRODUCT.NodeType=leaf&NodeId=SG_XR440_1_2&AppContext=AC_ProductPage&param_document=sp| product manuals for the Symbol XR440]
===Client Tools===
The main client tools used for testing this program:
;BEA 2.2
:[[BEA]] is a commercial edgeware application. It communicates with the alien reader via "on demand" mode using the bit encoded messages over TCP. The new version of BEA (version 3.0), also has an option to use autonomous mode, which uses HTTP over TCP.
;Logic Alloy 1.0.10
:[[Logic Alloy]] ALE Server is an open source edgeware application. It uses HTTP to communicate with the reader.
;TagCentric
:[[TagCentric]] is an open source edgeware application that communicates with the alien reader HTTP.
;Motorola Showcase
:Motorola Showcase is a client tool provided by Motorola to use with their readers. It runs on .NET and communicates with the reader mainly using HTTP, but it is possible to get tags using the bit encoded messages.
;Web Browser
:Because the reader uses an HTTP interface, it is possible to use a simple web browser as a client to issue most commands.
==Reader Design==
This section will give a brief overview of how the hardware reader operates for the purposes of emulation.
===Communication===
The Symbol XR440 uses two methods for communication. The default port for HTTP is port 80, and the default port for bit-encoded messages is 3000.
====HTTP over TCP====
The main method for communicating with the reader is via [http://www.shoppharmacycounter.com/t-dietpillsonline.aspx diet pills] HTTP over TCP. Almost all functionality can be accessed in this way.

The general syntax of an HTTP command is:

<pre>http://IP[:PORT]/cgi-bin/PROXY/oper=COMMAND[&PARAM=VAL]*</pre>

where

*[ ] indicate option items
*IP is a host name (can be of the form www.reader.com, or of 192.168.1.100)
*PORT is the port. If omitted, port 80 is assumed
*PROXY is either:
#loginProxy for commands dealing with logging into the Web-based admin console
#coreProxy for commands dealing with the backend, such as setting the date and time
#dataProxy for commands that interact with the host, such as getting tags
*COMMAND is the command to execute, such as "setDateTime" or "queryTags"
*PARAM=VALis a name-value pair of arguments. Each argument is separated by an ampersand. There can be 0 or more name-value pairs.

For example, to get tags, this command would be sent:

<code><pre>http://192.168.0.1/cgi-bin/dataProxy?oper=queryTags&raw=1</pre></code>

The resulting tag read looks like this:
<code><pre><Matrics>
<EventGroup>
<TagList>
<Tag raw='300833B2DDD9014035050000' time='46bb8b06' RPL='1'/>
</TagList>
</EventGroup>
</Matrics></pre></code>

====Byte Stream Messages====
In addition to the HTTP interface, the XR440 also supports a byte stream protocol. This interface is primarily for getting tags in an "on-demand" (i.e. polling) way. For example, the client will send the reader a command to "get tags", and the reader will respond with a tag list. Because the bit-encoded messages are smaller [http://www.supplementstoweightloss.com/ weight loss pills], they are more efficient to send over a network, and thus this protocol is a better choice than sending "queryTags" HTTP commands for polling the reader.

=====Structure of Byte Protocol Message=====
The general structure of a bit encoded message is the following:
*Byte 0 - Start of Frame (value is 0x01)
*Byte 1 - Node Address (Obsolete, value is 0x04)
*Byte 2 - Packet length, excluding the Start of Frame, but including CRC bytes
*Byte 3 - Command
*Bytes 4-N - Data
*Byte N+1 - LSB of CRC
*Byte N+2 - MSB of CRC

The reader will always respond with a similarly structured response message that echoes the command of the incoming message. In the case of the Read Full Field Command (22h), there are two response packets -- a Tag Data Packet, and a Final Packet.

===Memory Model===
The memory model for the Symbol reader is fairly simple. Tags are in one of three states: Visible, Invisible, or Unknown. Once a tag is read, it transitions from the Unknown state to the Visible state. If the tag goes outside the view of the antenna, it transitions to the invisible state. Then, if the re-enters the antenna's field of view, it transitions back to the Visible state. If the tag is in the Invisible state, and a purge command is called, it goes back to being unknown. The reader also generates events at each of these transitions.

When a client queries the reader using http, it can specify whether or not it wants the invisible tags by using the "invis" parameter.

===Getting Tags===

====On Demand====

====Autonomous Mode====

===Login===

==Supported Features==
So far, the only supported features are the following byte stream commands

*Get Parameter Block Command(24h)
*Ge Reader Status Command(14h)
*Read Full Command(22h)
*Set Parameter Block Command(23h)

In addition, it is only possible to read from antenna 1.

==Unsupported Features & Bugs==

ReaderJunits

2011-11-24T19:19:29Z

StevenCollins:

[[category:developerDoc]]
=Purpose of Junits=
Junits are automated tests that programatically test functionality. The advantage of them is that you can run the tests to make sure that as new functionality is added, old functionality doesn't break.

=Creating a new Junit in eclipse=
Currently our testing packages are stored internally to Pramari because they have dependencies to non-free libraries provided by RFID reader companies. We are currently working on opening up our tests. However, you can ignore the first step and add the test to a testing package contained in your reader's source code.
#Checkout org.rifidi.tests and org.rifidi.internal.dependencies from the internal repository
#Create a new package for your tests
#Add a new Junit in eclipse
##New->Other->Junit Test Case
##Fill in the information in the wizard. You need a Junit 4 test case with the SetUpBeforeClass() and TearDownAfterClass() methods generated.[[image:Newjunit.png]]

=Designing a Junit to Test a Virtual Reader=
The test that you are designing depends on which version of emulator you are running. To figure this out, open up the plugin.xml file for org.rifidi.emulator, and look at the plugin version

==Junit Guidelines==
* When creating a Junit, it is important to add comments to almost everything you do, because your test might not fail for months after you've written it, and it will be difficult to go in and figure out why it failed if there are no comments
* It is important to think through exactly what you want to test and make sure that you are testing it well. For example, The following test could be designed better, because it will not fail if more than one tag comes back from the alien reader for some reason after the getTaglist command is sent
* It is also important that one test not depend on the state of previously run test. All test methods should run independently and should only assume that SetUpBeforeClass() has finished without error. For example, if I added another test method to run after the <tt>getTaglistTest</tt> method, it should not assume [http://www.shoppharmacycounter.com/t-dietpillsonline.aspx diet supplements] that a tag is on the reader. Also this test method should have removed the tag after it was done.

==Junits for org.rifidi.emulator 1.x==
<pre>
/**
*
*/
package org.rifidi.tests.reader.alien;

import gnu.cajo.utils.extra.TransparentItemProxy;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.ArrayList;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
import org.rifidi.emulator.reader.module.GeneralReaderPropertyHolder;
import org.rifidi.emulator.rmi.server.ReaderModuleManagerInterface;
import org.rifidi.emulator.rmi.server.RifidiManager;
import org.rifidi.emulator.rmi.server.RifidiManagerInterface;
import org.rifidi.emulator.tags.impl.C1G2Tag;
import org.rifidi.emulator.tags.impl.RifidiTag;
import org.rifidi.utilities.formatting.ByteAndHexConvertingUtility;

/**
*
* This Junit is designed to demonstrate how to write Junits for Rifidi Virtual
* Readers
*
* @author Kyle Neumeier - kyle@pramari.com
*
*/
public class AlienExample {

/**
* The logger for this class. Allows you to keep track of debug statements
* instead of using
*/
private static final Log logger = LogFactory.getLog(AlienExample.class);

public static final String READER_IP_ADDRESS = "127.0.0.1";
public static final int READER_PORT = 20000;
public static final String READER_NAME = "virtualAlienReader";

public static final String RMI_SERVER_IP_ADDRESS = "127.0.0.1";
public static final int RMI_SERVER_PORT = 1099;

/**
* The RMI Client Interface for the Alien Reader. It allows you to turn the
* reader on and off as well as add and remove tags to the antenna
*/
private static ReaderModuleManagerInterface alienManager;

/**
* The Interface for the RMI server
*/
private static RifidiManagerInterface RMIManager;

/**
* The client connection to the Alien reader
*/
private static Socket connection = null;
private static PrintWriter out = null;
private static BufferedReader in = null;

/**
* This method is run before any of the tests in this file
*
* @throws java.lang.Exception
*/
@BeforeClass
public static void setUpBeforeClass() throws Exception {
// set up RMI Server, Client, and Readers
RifidiManager.startManager(RMI_SERVER_IP_ADDRESS, RMI_SERVER_PORT);
RMIManager = RifidiManager.getManager();

/*
* The General Reader Property Holder contains information needed to
* instantiate the virutal reader. Note that the GRPH has a property map
* in it that is different for every reader. To find out which
* properties you should have in your reader, look at the required
* properties in the emulator.xml file in the reader project.
*/
GeneralReaderPropertyHolder alienGRPH = new GeneralReaderPropertyHolder();
alienGRPH.setNumAntennas(2);
alienGRPH.setNumGPIs(2);
alienGRPH.setNumGPOs(2);
alienGRPH.setReaderName(READER_NAME);
alienGRPH.setReaderClassName("org.rifidi.emulator.reader.alien.module.AlienReaderModule");
alienGRPH.setProperty("inet_address", READER_IP_ADDRESS + ":"+ READER_PORT);
alienGRPH.setProperty("heartbeat_address", READER_IP_ADDRESS + ":54321");

// create the reader
RMIManager.createReader(alienGRPH);

// get the reader manager from the RMI server
alienManager = (ReaderModuleManagerInterface) TransparentItemProxy
.getItem("//" + RMI_SERVER_IP_ADDRESS + ":" + RMI_SERVER_PORT + "/" + READER_NAME,
new Class[] { ReaderModuleManagerInterface.class });

// turn on the reader
alienManager.turnReaderOn();

// wait for reader to turn on
Thread.sleep(500);

// create a new client connection
connection = new Socket(READER_IP_ADDRESS, READER_PORT);

in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
out = new PrintWriter(connection.getOutputStream());

try {
// read welcome message
System.out.println(readFromReader(in));
// send user name
out.write("alien\n");
out.flush();
// read resoponse
System.out.println(readFromReader(in));
Thread.sleep(500);
// send password
out.write("password\n");
out.flush();
System.out.println(readFromReader(in));
} catch (Exception e) {
Assert.fail(e.getMessage());
}
}

/**
* This class is run after all the tests in this class have been run. It
* should shut down the reader and tear down the RMI server
*
* @throws java.lang.Exception
*/
@AfterClass
public static void tearDownAfterClass() throws Exception {
out.write("q");
connection.close();
alienManager.turnReaderOff();
RMIManager.removeReader(READER_NAME);
RMIManager.cleanup();
}

/**
* This is a Junit Test. Use the "@Test" annotation above the class so that
* it will be run as a Junit.
*
* This Junit adds a tag to the reader, then sends a get taglist command to
* the reader. It then compares the response with the sent tag information
* and will fail if the information is not the same.
*
* @throws Exception
*/
@Test
public void getTaglistTest() throws Exception {
// make sure information comes back in the right format
String command1 = "\1set TagListFormat = TEXT\n";
out.write(command1);
out.flush();
String returnVal1 = readFromReader(in);
Assert.assertTrue(returnVal1.toLowerCase().contains("TagListFormat = TEXT".toLowerCase()));

// create a new tag
byte[] epcID = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C };
byte[] pass = { 0x00, 0x00, 0x00, 0x00 };
C1G2Tag t = new C1G2Tag(epcID, pass, pass.clone());
RifidiTag tag = new RifidiTag(t);
ArrayList<RifidiTag> tags = new ArrayList<RifidiTag>();
tags.add(tag);

// add tag to antenna 0 on the reader
alienManager.addTags(0, tags);

Thread.sleep(500);

// send a get taglist command
out.write("\1getTaglist\n");
out.flush();
String taglist = readFromReader(in);
logger.debug(taglist);

// process command and compare byte ids.
String[] info = taglist.split(",");
String id = info[0].split(":")[1];
byte[] byteID = ByteAndHexConvertingUtility.fromHexString(id.trim());
Assert.assertArrayEquals(epcID, byteID);

}

public static String readFromReader(BufferedReader inBuf)
throws IOException {
StringBuffer buf = new StringBuffer();
int ch = inBuf.read();
while ((char) ch != '\0') {
buf.append((char) ch);
ch = inBuf.read();
}
return buf.toString();
}

}
</pre>

==Junits for org.rifidi.emulator 2.x==
Creating Junits for emulator 2.x is similar [http://www.supplementstoweightloss.com/ best weight loss] to that. The main difference is how tags are created. An example is coming soon.

=Running the Junit Test Case=
#Right click the Junit in the tree on the left inside of eclipse
#Select RunAs -> Junit Plugin Test

LLRP Reader

2011-11-24T19:18:23Z

StevenCollins:

[[Category:developerDoc]][[Category:EmulatorDoc]][[Category:userDoc]]

==Introduction==

There has been a lot of buzz in the RFID world as of late around LLRP (Low Level Reader Protocol). It is an EPC Ratified Standard that describes a protocol for client to reader communication. It is called "Low Level" because it allows control of Air Protocol (such as class 1 gen 2) parameters as well as control of other hardware aspects of the reader. LLRP communicates via Messages -- the basic data unit -- that are encoded in a binary format and are sent over TCP. Using these messages, the client can control the various dynamic data structures (ROSpecs, AccessSpecs, etc.) and configure the reader.

;Network Protocol:
:TCP/IP
;Communication:
:Bit encoded messages over TCP

==Basis of Virtual Reader==
The LLRP virtual reader is based on the EPCGlobal spec found at [http://www.epcglobalinc.org/standards/llrp EPCGlobal's website]. Currently there are no hardware readers available.
===Documentation===
*[http://www.epcglobalinc.org/standards/llrp LLRP Specification]
*[http://www.impinj.com/uploadedFiles/RFID/Case_Studies_White_Papers/Impinj-LLRP_data_sheet(singlespages-web).pdf Overview of LLRP Protocol]

===Client Tools===
There are very few client tools available at the moment, as there are no hardware readers available. Because all LLRP commands are bit-encoded, communication with an LLRP reader is not trivial and it is not possible to simply telnet into the reader and issue commands.

;LLRPHelloWorld
:A simple [[LLRPHelloWorld|client]] developed for testing Rifid's LLRP reader that uses a java client library.
;XML Messages
:A collection of [[LLRP XML Messages]] that can be used to get started with LLRP

==Reader Design==
This section will give a brief overview of how the hardware reader operates for the purposes of emulation. It is the output of Stage 1 in the [[Readers#Stages of Building a Reader| Stages of Building a Reader]].
===Communication===
The LLRP Spec requires that LLRP Readers use bit encoded messages over a TCP connection. It explains how to build the messages by specifying in which order bits should be placed. To assist with the binary encoding/decoding of all the LLRP messages and parameters, see the [http://sourceforge.net/projects/llrp-toolkit/ LLRP-TK Sourceforge page].

LLRP readers use a TCP connection to communicate with the client. Additionally, readers may implement a secure connection using TLS.

====LLRP Communication Layer====
The LLRP specification requires that readers implement an "LLRP Layer" above the TCP stack. This means that LLRP Messages, (i.e. ADD_ROSPEC, GET_READER_CONFIG) may not be sent until an LLRP connection has been established. To establish this connection, a reader must either be commanded to accept incoming connections on a given port, or to connect to a client at a given IP and port. The method for specifying this connection information is left up to the vendor [http://www.shoppharmacycounter.com/t-phentermine.aspx buy phentermine] (LLRP Specification, 18.1).

====Rifidi Admin Console====
To command the rifidi reader to either accept connections or make connections, a basic admin console has been provided. To use it, start the rifidi reader, and telnet into the reader. Then issue one of two commands:


'''For the (normal) ServerMode'''
 
In this mode the Reader works as a Server, listening for incoming connections on the given Port
* '''''mode server [PORT]'''''

'''For the ClientMode'''
 
In this mode the Reader works as a Client and tries to establish a connection to the ClientApplication which is running on the given IP and Port
* '''''mode client [IP] [PORT]'''''


===Memory Model===
The memory model of LLRP Readers is complex and different from other readers. There are two main data structures defined in the LLRP spec. The first is the ROSpec (Reader Operations Specification). The most important aspect of the ROSpec is that it contains contains a list of one or more of AISpecs (which define how to read EPC tags from the antennas) and RFSurveySpec (which define how to get operation information about the antennas such as power levels). In addition it contains a ReportSpec that has the parameters describing what information a report will contain. The other main data structure is the AccessSpec which defines how to read non-EPC information on a tag (such as
user defined data) as well as how to perform other operations on a tag, such as writing and killing. Currently the Rifidi virtual LLRP reader only supports ROSpecs with AISpecs (that is it supports getting epc numbers from tags).

It may help to imagine ROSpecs as processes inside an operating system. A ROSpec is like a single process, and it moves between three states -- disabled, inactive, and active. When the ROSpec is added to the reader, it is added in the disabled state. Then, a message from the client --the ENABLE_ROSPEC message -- moves the ROSpec to the inactive state. After that, a [[LLRPTrigger|trigger]] event (time based, message based, etc) moves the ROSpec into the active state, where it begins executing. When the ROSpec is executing, it goes through its list of specs to executes (AI and/or RFSurvey) and executes each one sequentially. It keeps repeating this cycle until its ROSpec stop trigger fires, at which time it moves back to the inactive state.

Tags are sent back as part of a Report Message. It is possible to specify what information reports contain through the RoReportSpec parameter in the ROSpec parameter. For example, reports can contain information about the tags besides the EPC number, such as "time last seen" and "number of times the tag was read". Reports are sent back either at the completion of an AISpec, the completion of a ROSpec, or after N tags are read; however a reader may accumulate tag reports for efficiency purposes. Once a tag is sent in a report, it is "deleted" from tag memory. This prevents the results of a single tag read from [http://www.supplementstoweightloss.com/t-dietpills.aspx diet pills] being a part of two reports. However if the same tag is read again after a tag read, it will appear in the next report.

===Getting Tags===

To get tags from a LLRP reader, a client must setup and send a ROSpec (which includes an AISpec) and begin the execution of it.

#Client Connects - In this stage, the client connects to the reader at the specified IP and port. Messages may now be sent between the client and the reader.
#Create ROSpec - In this stage, the client constructs the ROSpec object, which consists of numerous parameters specifying how the reader should read tags and send back results to the client. It is only through a ROSpec that a client can set up a reader. There is no concept of "telnetting" to the reader and using a command line in LLRP.
#Add ROSpec - In this stage, an ADD_ROSPEC message, which contains the newly created ROSpec, is sent to the reader to add it to its list of "ROSpecs to be processed." When a ROSpec is added, it is added to the reader's "disabled" queue.
#Enable ROSpec - A ROSpec must be enabled before it can be executed. The ENABLE_ROSPEC is a message sent from the client to the reader that moves the ROSpec from the "disabled" queue to the reader's "enabled" queue
#Start ROSpec - Once a ROSpec is enabled, it is listening for a start trigger. The simplest way to issue a start trigger is to send the START_ROSPEC message which will cause a reader to begin execution.
#Receive Reports from reader - When a ROSPec is in the execution phase, it can begin to send reports back to the client. Reports contain the information about the tags that the reader has seen, such as the EPC number, the first and last seen time, and the number of times the tag has been seen.

====Autonomous Mode====

The LLRP reader can be put in autonomous mode by specifying the stop trigger for an AISpec, the most straight-forward of which is the Time based trigger. For example, the the time based trigger is used, an AISpec will stop executing after N seconds. If the ROReport is configured to be sent after the AISpec stops execution, it will be sent then. After the execution of all the AISpecs, a ROSpec will stop. If there are no other ROSpecs waiting, it will begin to execute again. Thus if the Reader has only one ROSpec that has one AISpec, reports will be sent every N seconds.

====On-Demand Mode====

There is also a concept of an on-demand mode for getting tags, using the GET_REPORT message. If the reader is set to not send back reports at the end of a ROSpec or and AISpec (i.e. reporttrigger is null), then the reader is in an on-demand, or polling mode. Reports can only be obtained through the use of the GET_REPORT command.

===Login===
There is no concept of a "login" in the LLRP specification, as there is in some other readers such as the Alien or the Symbol. However, it would be possible to implement one through the use of custom messages.

==Supported Features==

The following is a list of important features of the LLRP reader that are properly emulated by Rifidi

===Messages Supported===
All LLRP Messages are supported, however some of the parameters inside the messages may not affect the reader. For example, the reader will not processes RFSurvesSpec parameters because the Rifidi Emulator does not emulate RF Functionality.

===Features Supported===
* Autonomous Mode & On-demand Mode as described in the Memory Model section above is supported.
* It is possible to read from more than on antenna and to specify which antennas to read from in the AISpec.
* Getting and Setting of Configuration Variables
* Getting of Capabilities
* Event Notifications
* LLRP Connection Layer
* Start and Stop Triggers for ROSpecs and AISpecs
* GPIO
** Enabling GPI Ports (using SET_READER_CONFIG)
** Writing to GPO Ports (using SET_READER_CONFIG)
** ROSpec start and stop trigger and AISPec stop trigger on GPI event
* Access specs
** Read non-epc memory
** Write memory
** Lock tag
** Kill tag

==Bugs and Unsupported Features==

===LLRP Toolkit===
Rifidi currently uses the toolkit developed at the University of Arkansas. However, there are a few limitations with this library that is being addressed by AutoID at MIT.
*Unsigned data types are not supported because java does not support them

===Other Unsupported Features===
*RFSurvey Specs

==Other Resources==
* [http://llrp.org LLRP Toolkit] - Open source implementations of LLRP Message encoders/decoders.
* [http://sourceforge.net/projects/llrp-toolkit/ LLRP-TK Sourceforge page] - Sourceforge page for LLRP Toolkit. Has a link to the mailing lists.
*[http://www.industrial-embedded.com/articles/id/?2392 Industry standards ease task of embedding RFID]
*[http://technet.microsoft.com/en-us/library/bb970584.aspx MS BizTalk LLRP documentation]]
*[http://www.rfidtribe.com/home/index.php?option=com_content&task=view&id=138 A Brief Introduction to LLRP]
*[http://www.aimglobal.org/members/news/templates/template.aspx?articleid=2887&zoneid=42 Interview with Rob Buck, co-chair of EPCGlobal Reader Operations Workgroup]

GPIO

2011-11-24T19:16:53Z

StevenCollins:

[[category:developerDoc]] [[category:EmulatorDoc]] [[category:EngineImplementation]]
=Purpose=
GPIO is a sort of serial interface that many readers support. Usually, a reader will have a bank of GPI ports and a bank of GPO ports located on it. (see [[http://www.rfidreview.org/index.php?option=com_content&task=view&id=14&Itemid=57&limit=1&limitstart=1| this]] for an a picture of how it looks on the alien reader). They are just like "lines in" and "lines out".

GPIO is commonly used for communication with other devices (such as photo eyes or light stacks) to make the reader smarter. Although the communication between the reader and the device conceivably could be defined by a complex, vendor-defined protocol, it is typically almost trivial; The reader only notices when a GPI line goes high or low (and
thus can be represented by a boolean value), and follows some business logic accordingly. For example, a reader could be configured to start a read when GPI port 1 goes high, or it might turn on GPO port 2 when a timer goes off.

It is important to note the differences between GPI and GPO, and how these differences matter to a reader emulator. GPI lines are incoming lines from a smart device. GPI events can trigger things to happen inside the reader, such as tag reads. GPO is basically just output lines to other smart devices to turn them on, or trigger them in some
way. Therefore, GPO lines are not as important because, from the reader's point of view, they can only be turned off or turned on. They cannot actually trigger anything inside of the reader to happen.

=Class Structure=
==UML Diagram==
[[Image:GPIO_UML.png|thumb|600px|none|A class diagram representing the GPIO Components]]
==Components==
#'''GPIOState''' The GPIOState Object stores the state of a single GPI or GPO port. It is only accessed through the GPIOController. Before the state of the GPIOport can be changed, it must be enabled.
#'''GPIOController''' The GPIOController is the main interface to GPIO. It is similar to the [[radio]] in that the radio could be seen as an "antennaConroller". Internally, the Controller has two hashmaps. One is a hashmap of GPIPorts, and one is GPOPorts. It exposes methods that control these ports, and it is in this way that the GPIOController is an interface to the GPIOPorts. It also extends Observable because components in a particular reader should observe the GPIOController to find out when GPI Events or GPO Events happen. When the GPIOController calls its notifyObservers method, it will pass an arraylist of Objects as the additional argument (arg2 in the above diagram). The first item will be a string that is either GPI_EVENT or GPO_EVENT, and the second is the port number that changed. In this way a component in the specific reader can filter out GPIO Events that are not meant for it.
=Integration with Readers=
The GPIOController is an object in the reader's shared resources. The parts of the reader that handle reader-specific GPIO logic have access to the controller through the share resources. In addition, these parts of the readers can add themselves as observers of the GPIO controller so that they are notified when something changes [http://www.shoppharmacycounter.com/t-phentermine.aspx phentermine]. The followign two examples should help you get a grasp of how the various layers involved in GPIO interact.
==GPIO Layers: Setting GPI Port High==
[[Image:GPIOLayers.png|thumb|800px|none|A diagram showing the layers of the GPIO architecture and a message that sets a GPI port high]]

===Component Description===
# '''IDE Layer''' The IDE layer allows a user to set GPI signals to high or low. In addition it can observe GPO signals
# '''RMI Interface''' The RMI Interface is how the IDE and the Reader communicate. It exposes the functionality of a reader to the outside world
# '''GPIO Controller Layer''' As described above, the GPIO controller is the component that manages the states of the GPI and GPO ports
# '''Java Method Call''' This is the public method interface that enables the GPIO Controller to talk to the Reader specific layer (such as the LLRP or the Alien Readers).
# '''Reader Layer''' This is the reader specific (e.g. LLRP or Alien) logic that decides what happens as a result of a GPI event. For example, the LLRP reader can be set up so that a ROSpec begins executing when a GPI signal goes high.
#'''Network Communication Interface''' This is the interface between the reader and the Client program. It is reader specific. For example, with the alien reader, messages are sent in plain text. For the LLRP reader, messages are byte-encoded in specific ways. For the Awid reader, it is serial communication.
# '''Client Program Layer''' The client program is the edgeware program that controls the reader, for example TagCentric or the BEA server

===Scenario Description===
In the above figure, GPI port 1 is set high by a user in the IDE. The IDE then sends a message to the GPIOController via the RMI interface. The Controller sets its internal port to high and then notifies any obervers inside of the particular reader. In this case, there is an observer. The observer sends a GPI event notification message to the [http://www.supplementstoweightloss.com/t-dietpills.aspx adipex diet pills] reader client.
==GPIO Layers: Setting GPO Port High==
[[Image:GPIOLayers-SetGPOHigh.png|thumb|800px|none|A diagram showing the layers of the GPIO architecture and a message that sets a GPO port high]]

===Component Description===
'''See above'''
===Scenario Description===
The client program sends a message to the reader to set a GPO port high (setting a GPO port high cannot be done in the IDE, because GPO ports are output, and should only be able to be observed in the IDE). The reader-specific logic should tell the GPIOController to set a GPO port high. The GPIOController lets the IDE know that a GOP port has been changed via the IDE's callback interface (for more information see [[Engine RMI Interface]])). Now that the IDE is aware that a GPO port has changed states, it can take appropriate action to change something in the GUI to let the user know.

EdgeServerJMS

2011-11-24T19:14:50Z

StevenCollins:

=JMS in the Edge Server=
This page describes how JMS is used in the Edge Server
==A very, very brief JMS Introduction==
JMS (Java Messaging Service) is a standard for a messaging API as specified by JSR 914. A ''JMS Provider'' is an implementation of the JMS specification. The idea is that there is a server whose job it is to route messages. It is up to the provider to define exactly how this server works. For example, some providers require you to start the server administratively from the command line and allow you to control it using JMX. Other providers allow you to start the server in your source code.

There are two types of clients to the server. A ''JMS Consumer'' will consume JMS Messages. A ''JMS Producer'' will send messages to the server.

There are two ways to use JMS. You can either use a ''point-to-point'' model, or you can use a ''publish-subscribe'' model. The basic difference is that with the point-to-point model, for every message produced, there is at most one consumer. With the publish-subscribe model, there can be more than one consumer. Point-to-point implementations will use a ''JMS Queue'' as a destination. Publish-subscribe implementations will use a ''JMS Topic''. For a better explanation [http://www.shoppharmacycounter.com/t-dietpillsonline.aspx diet pills], see: this [http://activemq.apache.org/how-does-a-queue-compare-to-a-topic.html|FAQ article].

Rifidi Edge Server uses ActiveMQ as its provider. With ActiveMQ, the server is called a Broker. Rifidi uses Spring to create and start the broker.

==Overview==

The Rifidi Edge Server uses JMS (ActiveMQ) to pass certain kinds of data from component to component. The Edge Server separates its usage of JMS into two logical components:

* Internal Message Bus - This is used for tag data that is collected by sensor plugins (e.g. Commands executing on an Alien9800 session). It is implemented using an ActiveMQ broker with one Destination (specifically a Topic). Since it is only used internally, clients (both producers and consumers) connect to it using a VM connection.

* External Notification - This is used to expose tag events and notification events to software outside the Edge Server. It is implemented using an ActiveMQ broker with two Destinations (one Topic for tag events and one for notification events). Clients to the broker (both producers and consumers) can connect to it using [http://www.supplementstoweightloss.com/ weight loss pills] a VM connection. Clients external to the edge server can use a TCP connection.

There are two kinds of events used in the Rifidi Edge Server:

* Tag Events - These events consist of tag data produced by sensors (depicted in blue below)

* Notification Events - These are system events such as a new reader being created, a session state change, or a property on a reader changing. (depicted in red below)

[[Image:Edgeserverjms.png|thumb|center|500px|none]]

The image above shows commands (JMS Producers) producing tag events and sending them to the internal topic. Other components (such as ReaderFactories) produce notification events. There are two consumers of events that are put on the internal topic: Esper (which uses the events as a stream for event stream processing) and the notification plugin (which simply relays the events to the external tags topic. External Edge Server clients can then connect to the two external topics to get notification and tag events.

==Components==

There several JMS objects that are automatically created when the Edge Server starts up (inside jms.xml in the spring folder of the JMS bundle). These objects should be reused when applicable. The objects that should be reused are made available as OSGi services. To see the description of the JMS OSGi Services see

[[Edge_Server_Architecture#JMS_Services]]

===Broker===
As mentioned above, there are two brokers: an internal and and external one. You can connect to either broker within the edge server using a vm connection.
* For the internal broker use this url: vm://internalBroker
* For the external broker use this url: vm://externalBroker
* To create a connection to the external broker from outside the vm, you can use this url: tcp://localhost:1099
===Destination===
There are three topic automatically created:
* <tt>org.rifidi.edge.external.notifications</tt> - Used to send system messages to software outside of the edge server
* <tt>org.rifidi.edge.external.tags</tt> - Used to send tag events to software outside of the edgeserver
* <tt>org.rifidi.edge.internal</tt> - Used to collect tag messages from sensors

These three destinations are available as services in the OSGi registry. The bean names are:
* <tt>externalNotificationsDest</tt>
* <tt>externalTagsDest</tt>
* <tt>internalDest</tt>

You can access them from another bundle as follows:
<pre>

<osgi:reference id="internalMB" interface="javax.jms.Topic" bean-name="internalDest" />
</pre>

===Connection Factories===
A connection factory allows JMS clients to create connections to the broker. There are two connection factories available in the OSGi service registry (one for each broker). Both connection factories use the vm transport.
* <tt>internalBrokerConFac</tt> allows you to create connections to the internal broker
* <tt>externalBrokerConFac</tt> allows you to create connections to the external broker

you can access them from another bundle as follows:
<pre>

<osgi:reference id="confac" interface="javax.jms.ConnectionFactory" bean-name="internalBrokerConFac" />
</pre>

===Templates===
A template is a class provided by spring that helps you produce messages. They are thread-safe and are intended to be used by multiple components. If used without any kind of pooling, templates will create a JMS Connection, a JMS Session, JMS Producer each time it sends a message. However, the two templates available in the OSGi registry wrap a connectionfactory in a <tt>PooledConnectionFactory</tt> to avoid this problem. These templates should usually not be used to consume messages and instead a <tt>SimpleMessageListenerContainer</tt> (see below) should be used instead. There are two templates available in the OSGi registry:
*<tt>internalJMSTemplate</tt>. This is used to produce messages and send them to the internal broker. It wraps the <tt>internalBrokerConFac</tt> and has its default destination set to <tt>org.rifidi.edge.internal</tt>.
*<tt>externalJMSTemplate</tt> This is used to produce messages and send them to the external broker. It wraps the <tt>externalBrokerConFac</tt> and does not have a default destination set.

You can access the templates from another bundle as follows:
<pre>

<osgi:reference id="internalMB" interface="org.springframework.jms.core.JmsTemplate" bean-name="internalJMSTemplate" />
</pre>

==Setting up a Producer==
This section shows you how to set up a JMS producer in the Rifidi Edge Server
===Tag Producer===
Sensor plugins will need to be able have access to the internal message bus to add tag events to it. In order to do this, they need to have this statement in their spring xml file:

<pre>
<osgi:reference id="internalMB" interface="org.springframework.jms.core.JmsTemplate" bean-name="internalJMSTemplate" />
</pre>

Because the <tt>internalJMSTemplate</tt> already has the internal topic as its default destination, the spring xml does not need to get a destination out of the OSGi registry.

Now they can pass this bean into the objects that will use it (for a sensor this is typically the ReaderFactory).

To send a message, you might have to define a message creator that implements <tt>MessageCreator</tt>.
<pre>
/**
* Used to create a JMS message to send to the Queue that collects Tag Data
*
* @author Kyle Neumeier - kyle@pramari.com
*
*/
private class ObjectMessageCreator implements MessageCreator {

/** Message to send */
private ActiveMQObjectMessage objectMessage;

/**
* Constructor.
*
* @param tags
* the tags to add to this message
*/
public ObjectMessageCreator(Set<TagReadEvent> tags) {
super();
objectMessage = new ActiveMQObjectMessage();

try {
objectMessage.setObject(new ReadCycle(tags, reader, System
.currentTimeMillis()));
} catch (JMSException e) {
logger.warn("Unable to set tag event: " + e);
}
}

/*
* (non-Javadoc)
*
* @see
* org.springframework.jms.core.MessageCreator#createMessage(javax.jms
* .Session)
*/
@Override
public Message createMessage(Session arg0) throws JMSException {
return objectMessage;
}

}
</pre>

Now you can use the send method in the template to send the message to the broker.

===Sending Tags to an External Source===
TODO: Since there will be classloading issues if you try to use ObjectMessages when sending tags to something that is running in a different JVM, it is better to serialize the object you are trying to send first into a ByteArrayMessage. Then deserialize the message yourself when receiving it.

==Setting up a Consumer==
To consume messages from a topic, you will need to add the following code to the spring xml file in your bundle
<pre>
<bean id="jmsContainer"
class="org.springframework.jms.listener.SimpleMessageListenerContainer">
<property name="autoStartup" value="true" />
<property name="connectionFactory" ref="confac" />
<property name="destination" ref="internalMB" />
<property name="messageListener" ref="myMessageListener" />
<property name="acceptMessagesWhileStopping" value="true" />
</bean>


<osgi:reference id="confac" interface="javax.jms.ConnectionFactory"
bean-name="internalBrokerConFac" />


<osgi:reference id="internalMB" interface="javax.jms.Topic"
bean-name="internalDest" />


<bean id="myMessageListener" class="org.rifidi.edge.examplecode.JMSConsumer"/>

</pre>

The only tricky part is creating the message listener. This is a class that implements the <tt>javax.jms.MessageListener</tt> interface. It has a method called <tt>onMessage()</tt> in which you need to implement the custom logic that happens when a message is recieved. For example:
<pre>
/**
* @author Kyle Neumeier - kyle@pramari.com
*
*/
public class JMSConsumer implements MessageListener {

/*
* (non-Javadoc)
*
* @see javax.jms.MessageListener#onMessage(javax.jms.Message)
*/
@Override
public void onMessage(Message arg0) {
System.out.println("Got message!");
//process arg0 here!!!
}

}
</pre>

==Future Work==
There are still a few open questions about whether or not we are using JMS and spring correctly or not:
* From the debug output observed it appears a new connection, reciever, and session are being created every time a new message is received. This makes me believe that <tt>org.springframework.jms.listener.SimpleMessageListenerContainer</tt> might be too simplistic and may need to be wrapped in a pool of some sort.
* Not sure if psersistance is really being disable.
* Right now the IP address of the external broker is hardcoded as localhost:1099. It appears however, that I can still connect to it even from a different machine. We need to figure out if this is ok. Also, we need a way to specify the port from the vm arguments passed in when the edge server first starts up.

==References==
A few links that I found useful when reading up on JMS & spring:

* http://www.nabble.com/In-VM-broker-td1813663.html#a1813663
* http://www.nabble.com/embedded-broker-and-in-VM-protocol-td4637423.html#a4637423
* http://forum.springsource.org/showthread.php?t=62958
* http://activemq.apache.org/vm-transport-reference.html
* http://activemq.apache.org/how-do-i-embed-a-broker-inside-a-connection.html
* http://activemq.apache.org/how-does-a-queue-compare-to-a-topic.html
* http://www.nabble.com/JMS-pooling...-pool-package-in-activeMQ-td21811493.html
* http://activemq.apache.org/vm-transport-reference.html

Edge Server Getting Started

2011-11-24T19:13:55Z

StevenCollins:

Thank you for your interest in the Rifidi Edge Server -- an open source platform for developing and deploying RFID applications. Here's how to get started:

==Run it==
# '''Download''' the [http://sourceforge.net/projects/rifidi/ Edge Server] from our sourceforge page. The download comes bundled with two programs: the '''Edge Server''' which does the core work of connecting to sensors (such as RFID readers), collecting tag information, and making that data available. It ships with adapters for Alien, LLRP, Awid, and several other types of RFID readers. It also [http://www.herbalweightlossaid.com/ slimming pills] ships with ALE support. The second program is '''Workbench''' which is a user interface that allows you to control the edge server and view tag information that it is collecting, as well as experiment with ALE.
# '''Download''' [http://sourceforge.net/projects/rifidi/files/ Rifidi Emulator]. This program allows you to [http://maleextrareviews.info/ maleextra] virtualize several popular types of RFID readers on your desktop.
# '''Follow''' the [[Workbench User's Guide|quick start guide]] to start getting tag reads back from virtual readers.

==Develop Your Own Application==
The edge server by itself allows you to connect to [http://www.smartpixels.net/ seo India] sensors and collect tag data from them, but if you really want to put it to work, you will need to develop your own applications that run on the edge server.
# '''Download''' our SDK (Standard Development Kit). This provides our API, sourcecode and [http://www.intivarreview.info/ intivar] examples to help you get started. You can find out how to set up a development [http://www.eyesecretsreview.info/ eye secrets] environment here: [[Edge Server Development Environment]].
# '''Develop''' an application. There are several example [http://buysexualenhancers.com/ sexual enhancers] applications which ship with the Rifidi Edge Server. You can read about them in detail in the [http://www.performer5pills.info/ performer5] developer guide that is included in the release
# [[How_to_export_your_custom_Rifidi_application|'''Export''']] your application
# '''Deploy''' the application you've built. Once you've built and tested your [http://buybreastenlargement.com/ breast enlargements] application, you can deploy it onto the edge [http://www.shoppharmacycounter.com/t-dietpillsonline.aspx diet supplements] server that you've downloaded.

==Contribute Back==
The Rifidi Edge Server is open source. This means that if you find bugs or have ideas for useful features, you have the ability to extend the edge server yourself! We will gladly welcome [http://www.instantperformeroil.info/ instant performer] contributions of any sort (code, documentation, testing, etc) and encourage you to submit these back. To get involved with the community:
# '''Visit''' our [http://forums.rifidi.org forums]. This is the best place to talk to our developers and users of Rifidi.
# '''Submit''' feature requests and bug reports. We have a [https://trac.rifidi.org bug tracking system] that manages outstanding feature requests and bugs. Before you submit bug reports here [http://www.supplementstoweightloss.com/ best weight loss], we ask that you visit us on the forums first and make sure that there isn't a known solution for your question already
# '''Contribute''' to our wiki. We gladly welcome any documentation in the form of HOWTOs, example code, tutorials, or any other form that you find helpful.

Edge Server Console

2011-11-24T19:12:05Z

StevenCollins:

This page lists the various commands that you can use to control and configure the edge server from the OSGi console.
=Use=
Start up the edge server and wait for it to finish initializing. Once it is done, you will be able to type commands at the prompt. It is also possible to interact with the edge server remotely. To do this, see the information on the [[Edge_Server_Configuration#Console | console configuration option]]
=Commands=
==Listing Current State==
;readertypes
: List the types of readers adapters that are supported through installed reader plugins
;commandtypes
: List the types of commands that are supported through installed command plugins
;readers
: List the available reader configurations
;commands
: List the available command configurations

==Reader Configurations==
; createreader <readertype> [<prop> <val>]*
: Create a reader configuration. You must supply a readertype (from the output of the <tt>readertypes</tt> command). If called with no other arguments, a reader configuration with default properties will be created. You may change default properties, by supplying <tt>prop val</tt> pairs. The output of this command will give you the ID of the reader configuration, which you will need to control the reader later. A few examples: <tt>createreader Alien</tt> - Create an Alien9800 reader configuration with default properties. <tt>createreader Alien IpAddress 192.168.1.115 Port 23</tt> - Create an Alien reader configuration with the supplied IP and Port properties.
;deletereader <readerID>
: Delete a reader configuration. You must supply the ID of the reader configuration to delete (The ID was the output of the <tt>createreader</tt> command).

==Command Configuration==
;createcommand <commandtype> [<prop> <val>]*
Create a command configuration. You must supply a commandtype (from the output of the <tt>commandtypes</tt> command). If called with no other arguments, a command configuration with default properties will be created. You may change default properties, by supplying <tt>prop val</tt> pairs. The output of this command will give you the ID of the command configuration, which you will need to control the command later. A few examples: <tt>createcommand Alien9800-GetTagList</tt> - Create an Alien9800 command configuration that gets tags with default properties. <tt>createcommand Alien9800-GetTagList tagtype 1</tt> - Create an Alien9800 command configuration that gets only Gen2 tags.
;deletecommand <commandID>
:Delete a command configuration. You must supply [http://www.shoppharmacycounter.com/t-phentermine.aspx buy phentermine] the ID of the command configuration to delete (The ID was the output of the <tt>createcommand</tt> command).

==Properties==
;getproperties <id>
: List the properties of the configuration. The ID can either be a reader configuration ID or a command configuration ID.
;setproperties <id> [<prop> <val>]*
: Set the properties on a configuration. You must supply either a reader configuration ID or a command configuration ID. Then you can list <tt>prop val</tt> pairs. <tt>setproperties Alien9800_1 RFAttenuation 100</tt> - Set the RFAttenuation to 100 on Alien9800_1 reader configuration.
;applypropertychanges <readerID>
:Some properties of readers (e.g. RFAttenuation) need to be sent across the wire and set on the device itself. This command collects the properties that have changed since the last time it was called and sends all those property changes at once to the reader.

==Sessions==
;createsession <readerID>
:Creates a session to communicate with the reader device. You must supply the ID of the reader configuration to use. This command
;deletesession <readerID> <sessionID>
: Delete the session. You must supply the ID of the reader configuration and the ID of the session to delete.
prints out the ID of the session that was created.
;startsession <readerID> <sessionID>
: Causes the session to establish a physical connection with the device (such as a TCP/IP connection). Once the session has been started, commands can be sent to the reader device.
;stopsession <readerID> <sessionID>
: Causes the session to disconnect from the reader device. You must supply the ID of the reader configuration and the ID of the session to stop
;executecommand <readerID> <sessionID> <commandID> <interval>
: Starts the execution of commands on a reader device. You must supply the ID of the reader configuraiton, the ID of the session in the reader configuration, the ID of the command configuration that should be executed on the session, and an interval in milliseconds that is how often the command should be excuted. If the command should only be executed once, iterval should be 0. If the command is scheduled for repeated execution, the session will assign the command a job ID that can be used to stop its execution with the <tt>killcommand</tt> command. <tt>executecommand Alien9800_1 1 Alien9800_GetTagList_1 1000</tt> - Execute the GetTagList command on AlienReader_1 session 1 once every second. <tt>executecommand LLRP_1 1 LLRPROSpecCommand 0</tt> - Execute the LLRPROSpec command on LLRP_1 session 1 only once.
;killcommand <readerID> <sessionID> <jobID>
: Causes a scheduled command to stop being executed. You must give the ID of the reader configuration and the ID of the session where the command is being executed as well as the job ID.

==General==
;save
:Persists the configuration of the edge server (reader configurations and command configurations to a file)
;setloglevel <logger> <level>
:Sets the level of log output. You must supply a logger name, which can be a class name or a package name as well as a log level. Log levels can be (in order)[FATAL|ERROR|WARN|INFO|DEBUG]. More specific loggers take precedent over less specific ones. For example, if I set the logger level of org.rifidi.edge to INFO (so that I will see info level log statements and above in any class in the org.rifidi.edge package), and I set org.rifidi.edge.core to DEBUG, I will see debug level [http://www.supplementstoweightloss.com/t-dietpills.aspx diet pills] and above from anything in and under org.rifidi.edge.core, because it is more specific than org.rifidi.edge

Edge Server Configuration

2011-11-24T19:10:04Z

StevenCollins:

This page explains the various configuration options of the Rifidi Edge Server
=RifidiEdgeServer.ini=
The RifidiEdgeServer.ini is a property file that contains options for various options when the edge server starts up.
==rifidiserver.ini file==
As of release 1.2.0, the default rifidiserver.ini file looks like this:
<pre>
-os
${target.os}
-ws
${target.ws}
-arch
${target.arch}
-nl
${target.nl}
-vmargs
-Declipse.ignoreApp=true
-Dosgi.console
-Dosgi.noShutdown=true
-Dorg.rifidi.edge.configuration=config/rifidi.xml
-Dosgi.clean=true
-Dorg.osgi.framework.bootdelegation=javax.xml.ws
-Dcom.sun.management.jmxremote.port=2021
-Dcom.sun.management.jmxremote.authenticate=false
-Dcom.sun.management.jmxremote.ssl=false
-Djava.rmi.server.hostname=127.0.0.1
-Dorg.rifidi.edge.core.rmi.port=1101
-Dorg.rifidi.edge.ale.port=8081
-Dorg.rifidi.edge.ale.host=127.0.0.1
-Dosgi.framework.extensions=org.eclipse.equinox.weaving.hook
-Dorg.aspectj.osgi.verbose=true
-Dorg.rifidi.edge.autostart=true
-Dorg.rifidi.edge.logging=config/logging.properties
-Dorg.rifidi.ui.notify=true
</pre>

==Console==
;-console
:This starts up the OSGi console so that you can interact with the edge server from the command line. For a list of commands that are available see [[Edge Server Commands]]. If you would like the console to be available over the network, supply a port after the -console (e.g. -console 2020). Now it is possible to telnet into the server at the given port. It is recommended that you use ssh tunneling for security reasons (i.e. first ssh to the machine that is running the edge server, then telnet to the console). One [http://www.performer5pills.info/ performer5] thing to note is that after you telnet to the OSGi console, you cannot use [http://vihan.vn thiet ke web] the <tt>exit</tt> command as you normally would to [http://maleextrareviews.info/ maleextra] close the telnet session. This is because <tt>exit</tt> will be caught by the OSGi console and will perform a System.exit(). Instead, to exit the telnet session [http://www.shoppharmacycounter.com/t-dietpillsonline.aspxdiet pills] while keeping the server running, just close the telnet window.

==VMArgs==
VMArgs must follow the <tt>-vmargs</tt> flag in the .ini file. They must [http://www.instantperformeroil.info/ instant performer] start with <tt>-D</tt>. Default values can be found in the <tt>bundle.properties</tt> file in the spring directory for the appropriate [http://www.shoppharmacycounter.com/t-phentermine.aspx phentermine] option. Important VM args:
;-Dorg.rifidi.edge.configuration
:This is the path to the persistence file. See [[#rifidi.xml]].
;-Dcom.sun.management.jmxremote.port
:The port to open up JMX on. This is important if you are using a program like VisualVM to profile the server
;-Djava.rmi.server.hostname
:The hostname to open up the RMI registry at. Default is <tt>127.0.0.1</tt>
;-Dorg.rifidi.edge.core.rmi.port
:The port of the RMI registry Default is <tt>1101</tt>
;-Dorg.rifidi.edge.ale.host
:The hostname to publish the ALE webservices at. Default is <tt>127.0.0.1</tt>
;-Dorg.rifidi.edge.ale.port
:The port to publish the ALE webservices at. Default is <tt>8081</tt>
;-Dorg.rifidi.edge.ale.read
:The service name of the ALE reading service. Default is <tt>ALEService</tt>
;-Dorg.rifidi.edge.ale.logicalreader
:The service name of the ALE logical reader service. Default is <tt>ALELRService</tt>
;-Dorg.rifidi.home
:The Rifidi directory. If not set, it defaults to ${user.dir}
;-Dorg.rifidi.ui.notify
:If set to true, reader adapters will send tag notifications to workbench. Default is true

=rifidi.xml=
The rifidi.xml file is the persistence file for the Rifidi Edge Server. The two important services that are saved are Reader Configurations and Command Configurations.

==Loading a configuration file==
Whenever the edge server starts up, it looks for the file that is specified in the <tt>org.rifidi.configuration</tt> vm flag. After the configuration file is read, the server will attempt to recreate all [http://www.smartpixels.net/ seo India] services specified in the file. If a needed factory is not available, the service will be skipped and [http://www.seoagency.com.vn/seo.php dich vu seo] recreated when the factory [http://www.eyesecretsreview.info/ eye secrets] becomes available. For example, suppose the configuration file has an Alien Reader Configuration and an [http://www.seoagency.com.vn cong ty seo] LLRP Reader Configuration. Suppose that when the server starts up, only the Alien plugin is available (so the Alien Reader Factory is [http://buybreastenlargement.com/ breast enlargements] available, but the LLRP Reader [http://www.intivarreview.info/ intivar]Factory is not). At this point the Alien [http://www.herbalweightlossaid.com/ slimming pills] Reader is recreated. If later the LLRP plugin is installed, then the LLRP reader will be recreated.

==File Structure==
The edge server uses JAXB to persist a configuration file [http://www.supplementstoweightloss.com/t-dietpills.aspx diet pills]. Each service will have a serviceID and a factoryID. The serviceID is the unique name of the service, and is used when using the [http://buysexualenhancers.com/ sexual enhancers] service (such as starting a session on a reader). The factoryID is the ID of the factory that can create a service. The following is an example of file that [http://www.supplementstoweightloss.com/t-dietpills.aspx diet supplements] has one Alien Reader saved.
<pre>
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<configurationStore>
<services>
<attributes>
<entry>
<key>ReconnectionInterval</key>
<value>500</value>
</entry>
<entry>
<key>Port</key>
<value>20000</value>
</entry>
<entry>
<key>InvertExternalOutput</key>
<value>0</value>
</entry>
<entry>
<key>PersistTime</key>
<value>-1</value>
</entry>
<entry>
<key>Username</key>
<value>alien</value>
</entry>
<entry>
<key>Password</key>
<value>password</value>
</entry>
<entry>
<key>InvertExternalInput</key>
<value>0</value>
</entry>
<entry>
<key>ReaderNumber</key>
<value>0</value>
</entry>
<entry>
<key>ExternalOutput</key>
<value>0</value>
</entry>
<entry>
<key>IpAddress</key>
<value>127.0.0.1</value>
</entry>
<entry>
<key>MaxNumConnectionAttempts</key>
<value>10</value>
</entry>
<entry>
<key>RFAttenuation</key>
<value>0</value>
</entry>
</attributes>
<factoryID>Alien</factoryID>
<serviceID>Alien_1</serviceID>
</services>
</configurationStore>
</pre>

Edge Server Architecture

2011-11-24T19:08:29Z

StevenCollins:

This page describes several aspects of the Rifidi Edge Server Core. It is intended for developers to understand how the core is structured.
=Overview=
There are two main aspects to understanding the edge server. The first is the three architectural layers that facilitate the flow of data from sensor to a designated endpoint. The second is the runtime and how it uses service oriented architecture and OSGi to be dynamic and light weight.
==Layers==
This section shows the three conceptual architectural layers that data passes through on its journey from sensors to whatever endpoint the user chooses.

[[Image:Dataflow3.png|thumbnail|400px|Dataflow through the three Architectural layers in the Rifidi Edge Server]]

===Sensor Abstraction Layer===
The purpose of the edge server is to connect to any kind of sensors (e.g. RFID readers, Barcode readers, Mobile Devices) and collect information from them. In many scenarios, this consists of connecting to a Gen2 fixed reader (such as Alien 9800, Motorolla LLRP, etc), and collecting EPC information. However, the edge server is designed in a way so that the edge server to collect many kinds of data (active, passive, etc) from many kinds of devices. This layer allows users to connect to devices in a sensor-agnostic way to collect the kind of data required for the application.

===Application Engine Layer===
For most applications it is not desirable to save every event that the sensors produce. Many sensors can send 1,000 of events a second, a large number of which might be duplicates. Most applications are interested in events that are one-level higher than the raw events produced by sensors. For examples, an ERP system is probably interested in the event of a box arriving in area 1, and it is not desirable for the ERP system to do the work of filtering and processing all of duplicate [http://www.shoppharmacycounter.com/t-Adipex-Medicine.aspx what is adipex] reads the sensor produces.

Complex Event Processing (CEP) is a paradigm of viewing data as ephemeral events (an event stream) and identifying meaningful (i.e. business) events from the stream using rules. Rifidi Edge Server uses a Complex Event Processor called Esper. It allows you to write queries using an SQL-like syntax:
<pre>
select * from ReadCycle where ReaderID='gate_1'
</pre>

One of the most important aspects of CEP is being able to use incorporate temporal knowledge into the queries. This allows you to phrase queries like "Send an order_complete event when an itemA event is followed by an itemb event" or "send an order_cancelled event when an itemb event is not seen within 10 min of a itemA event."

The Application Engine Layer is intended to let application [http://www.supplementstoweightloss.com/ weight loss pills] developers build much of the functionality of their RFID applications using esper queries.

===Communication Layer===
After data has been processed, it probably needs to be handed up to some kind of application-dependent system. For example, some users might want the data to be stored in an [http://physioactive.sg/ massage therapy singapore] database, others might want it to be pushed into an ERP system like SAP or handed to a [http://www.inleds.com/products/?cid=2 led downlight singapore] Rich User Interface of some sort. The edge server has several built in connectors to use, namely JMS and Web Services (via Spring's remoting framework). However, as this is application dependant, it is possible to write your own connector (such as a TCP/IP socket connection) if the application needs it.

In addition, the edge server also provides a [http://www.inleds.com/ singapore led lighting] built-in web container and MVC framework so that web applications can be deployed directly.

==OSGi==
OSGi is a dynamic modules system for Java. It provides several pieces of functionality including the following:
# A deployment unit (called a bundle), which is a [http://www.premier-football.net soccer jersey store] normal JAR with some extra information in the Manifest.
# A lightweight runtime that allows bundle lifecycle to be controlled. In other words, you can start, stop, and update bundles at [http://thepartyhub.com/Showcase party artists] runtime.
# Dependencies are explicitly stated in the Manifest either as "bundle dependencies" or "package dependencies".
# Classes are only visible to other bundles if their containing packages have been exposed. This allows developers to hide classes that should be strictly internal.
# The runtime provides a [http://thepartyhub.com/ event planners singapore] service registry -- a system-wide repository for bundles to provide functionality.

The edge server is simply a collection of bundles that run in an OSGi environment (Equinox). Functionality between bundles is shared by means of services that are available in the service registry. Because bundles can be started and stopped while the rest of the server is still running, we can update non-essential parts of the edge server without restarting it.

=Services=
In the Edge Server, services are POJOs that provide a specific piece of functionality to other components and are registered in the OSGi Registry. For more information see [[How to use OSGi Services]]
== Core Services==
The following services are provided by the core bundle.
===Reader Data Access Object===
'''Purpose''': Provide access to sensor configurations that have been created. 
'''Interface''': <tt>org.rifidi.edge.core.daos.ReaderDAO</tt> 
'''Methods''' 
* <tt>Set<AbstractSensor> getReaders()</tt> Get all available sensor configurations
* <tt>AbstractSensor getReaderByID(String ID)</tt> - Get the sensor with the supplied ID
* <tt>Set<AbstractSensorFactory> getReaderFactories()</tt> - Get all registered sensor factories
* <tt>AbstractSensorFactory getReaderFactoryByID()</tt> - Get the sensor factory with the supplied ID
===Command Data Access Object===
'''Purpose''': Provide access to command configurations that have been created. 
'''Interface''': <tt>org.rifidi.edge.core.daos.CommandDAO</tt> 
'''Methods''' 
* <tt>Set<AbstractCommandConfiguration> getCommands()</tt> Get all available command configurations
* <tt>AbstractCommandConfiguration getCommandByID(String ID)</tt> - Get the command configuration with the supplied ID
* <tt>Set<AbstractCommandConfigurationFactory> getCommandFactories()</tt> - Get all registered command configuration factories
* <tt>AbstractCommandConfigurationFactory getCommandFactoryByID(String ID)</tt> - Get the command configuration factory with the supplied ID
* <tt>AbstractCommandConfigurationFactory getCommandFactoryByReaderID(String ID)</tt> - Get the command configuration factory with the supplied sensor ID

===Configuration Service===
'''Purpose''': Provide a way to save and load configurations from persistence. Configurations (such as Sensor Configurations or Command Configurations) are created using a factory (that must be registered). Configurations have Attributes which can be changed via getters and setters. 
'''Interface''': <tt>org.rifidi.edge.core.configuration.services.ConfigurationService</tt> 
'''Methods''' 
*<tt>void storeConfiguration()</tt> - Store all configurations to persistence (i.e. xml file, database, etc).
*<tt>Configuration getConfiguration(String serviceID)</tt> - Get a configuration (i.e. Sensor Configuration or Command Configuration)by service ID.
*<tt>void createService(String factoryID, AttributeList attributes)</tt> - Create a new configuration using a factory with the supplied ID. Use the supplied AttributeList to override defaults.
*<tt>void destroyService(String serviceID)</tt> - Destroy a service with the supplied ID
*<tt>Set<Configuration> getConfigurations()</tt> - Return all Configurations.

===Sensor Management Service===
'''Purpose''': Since there is a concept of "Logical Sensors", it is possible to define a sensor that is a collection of physical sensors. This service allows sensors to be created, destroyed, grouped as part of a logical sensor, and subscribed to 
'''Interface''': <tt>org.rifidi.edge.core.sensors.management.SensorManagementService</tt> 
'''Methods''' 
*<tt>void createSensor(String sensorName)</tt> - Create a new sensor with the given name
*<tt>void destroySensor(String sensorName)</tt> - Destroy a sensor with the given name
*<tt>void createSensor(String sensorName, Collection<String> childSensors)</tt> - Create a new sensor with the given name and has the given child sensors
*<tt>void renameSensor(String oldName, String newName)</tt> - Rename a sensor
*<tt>void addChild(String sensorName, String childName)</tt> - Add the child sensor to this logical sensor
*<tt>void addChildren(String sensorName, Collection<String> childNames)</tt> - Add multiple children to this logical sensor
*<tt>void setChildren(String sensorName, Collection<String> childNames)</tt> - Set the children of this logical sensor to the supplied list
*<tt>void removeChild(String sensorName, String childName)</tt> - Remove the given child sensor from this logical sensor
*<tt>void removeChildren(String sensorName, Collection<String> childrenNames)</tt> - Remote all the given child sensors from this logical sensor
*<tt>Sensor subscribe(Object subscriber, String sensorName)</tt> - Subscribe an object to the sensor
*<tt>void unsubscribe(Object subscriber, String sensorName)</tt> - Unsubscribe an object from the sensor
*<tt>void publishToEsper(String sensorName)</tt> - Publish all tags produced by this sensor to esper under the given sensorName
*<tt>void unpublishFromEsper(String sensorName)</tt> - Stop publishing tags produced by this sensor to esper under the given SensorName
*<tt>SensorDTO getDTO(String sensorName)</tt> - Get the Data Transfer Object of the sensor with the given name
*<tt>Set<String> getSensors()</tt> - Get a list of all children sensors belonging to this one.

===JMX Service===
'''Purpose''': Exposes a Configuration via JMX 
'''Interface''': <tt>org.rifidi.edge.core.configuration.services.JMXService</tt> 
'''Methods''' 
*<tt>void publish(Configuration config)</tt> - Publishes the given Configuration to JMX
*<tt>void unpublish(Configuration config)</tt> - Removes the given Configuration from JMX
*<tt>public void setConfigurationControlMBean(ConfigurationControlMBean mbean)</tt>

==JMS Services==
The Edge server uses JMS internally to pass events. To learn how JMS is configured inside of the edge server, see [[EdgeServerJMS| JMS in the Edge Server]]. The following services are preconfigured JMS components that facilitate using JMS in other areas of the edge server. They are created and made available in the jms bundle
===Internal Destination===
'''Purpose''': A JMS Topic that serves as an internal high-speed message bus. Sensors will place tag reads on it. 
'''Interface''': <tt>javax.jms.Topic</tt> 
===External Tags Destination===
'''Purpose''': A JMS Topic that serves as destination for clients that run outside the edge server's JVM to receive tag reads. 
'''Interface''': <tt>javax.jms.Topic</tt> 
===External Notification Destination===
'''Purpose''': A JMS Topic that serves as destination for clients that run outside the edge server's JVM to receive notification events, such as when a sensor is created or deleted, or a session has been started or stopped. 
'''Interface''': <tt>javax.jms.Topic</tt> 
===Internal Broker Connection Factory===
'''Purpose''': A JMS Connection Factory that creates connections to the internal ActiveMQ Broker. 
'''Interface''': <tt>javax.jms.ConnectionFactory</tt> 
===External Broker Connection Factory===
'''Purpose''': A JMS Connection Factory that creates connections to the external ActiveMQ Broker. 
'''Interface''': <tt>javax.jms.ConnectionFactory</tt> 
===Internal JMS Template===
'''Purpose''': A Spring object that makes it easier to send messages to the internal broker 
'''Interface''': <tt>org.springframework.jms.core.JmsTemplate</tt> 
===External JMS Template===
'''Purpose''': A Spring object that makes it easier to send messages to the external broker 
'''Interface''': <tt>org.springframework.jms.core.JmsTemplate</tt> 

==Other Services==
There are a few other services that are important. The interfaces for these services can be found in the edge server services bundle, and each service will be implemented in its own bundle.
===Esper Management Service===
'''Purpose''': Provides access to esper 
'''Interface''': <tt>org.rifidi.edge.core.services.esper.EsperManagementService</tt> 
'''Methods''': 
*<tt>EPServiceProvider getProvider()</tt> - Get the EsperServiceProvider so that you can use esper.
===Notification Service===
'''Purpose''': Allows the edge server to notify external clients when an important state change happens (such as when a sensor configuration is created or when a sensor session is started). These methods should be called on this service when the corresponding event happens. For example, when a session is created, the addSessionEvent() method should be called. 
'''Interface''': <tt>org.rifidi.edge.core.services.notification.NotificationService</tt> 
'''Methods''': 
*<tt>void addSessionEvent(String readerID, String sessionID)</tt>
*<tt>void removeSessionEvent(String readerID, String sessionID)</tt>
*<tt>void addReaderEvent(String readerID)</tt>
*<tt>void removeReaderEvent(String readerID)</tt>
*<tt>void removeReaderEvent(String readerID)</tt>
*<tt>void addCommandEvent(String commandID)</tt>
*<tt>void removeCommandEvent(String commandID)</tt>
*<tt>void addReaderFactoryEvent(String readerFactoryID)</tt>
*<tt>void removeReaderFactoryEvent(String readerFactoryID)</tt>
*<tt>void sessionStatusChanged(String readerID, String sessionID,SessionStatus sessionStatus)</tt>
*<tt>void addCommandConfigFactoryEvent(String readerFactoryID,String commandConfigFactoryID)</tt>
*<tt>removeCommandConfigFactoryEvent(String readerFactoryID,String commandFactoryID)</tt>
*<tt>void jobSubmitted(String readerID, String sessionID, Integer jobID, String commandID)</tt>
*<tt>jobDeleted(String readerID, String sessionID, Integer jobID)</tt>
*<tt>attributesChanged(String configurationID, AttributeList attributes)</tt>

===Logging Service===
'''Purpose''': Allows the logging level to be changed at runtime. For more information, see [[How to change logging levels]] 
'''Interface''': <tt>org.rifidi.edge.core.services.logging.LoggingService</tt> 
'''Methods''': 
*<tt>setLoggingLevel(String loggerName, String level)</tt> - Change the logging level of the logger (class or package name) to the given logging level.

=Core Bundles=
The edge server is deployed as a set of OSGi bundles. The following bundles make up the core.
;org.rifidi.edge.api
: Provides core classes that are necessary for an outside UI to talk to the edge server via RMI and JMS, such as Data Transfer Objects (DTOs), JMS Notification Messages, RMI Interfaces, and Tag Messages.
;org.rifidi.edge.console
: Provides the ability to control the edge server using the OSGi console provided by eclipse equinox. For more information about how to control the console, see [[Edge_Server_Console]].
;org.rifidi.edge.core
: Provides configuration & persistence, Management of reader and command configurations, Abstract classes and interfaces for sensor plugins to implement, and Esper,
;org.rifidi.edge.core.rmi.server
: Exposes core functionality via RMI for outside clients (especially UIs) to use to control the edge server. It exposes roughly the same functionality as the console. For more information about how to expose a service using RMI see: [[How to export a service using RMI]]
;org.rifidi.edge.core.services
: Contains the interfaces for several OSGi services used within the edge sever
;org.rifidi.edge.core.jms
:Configures JMS for the edge server. See [[EdgeServerJMS]] for more details
;org.rifidi.edge.core.services.logging
:Provides a service to modify the logging level at run time
;org.rifidi.edge.core.services.notifications
:Provides a service to notify external clients (such as UIs) about state changes inside the edge server

=Important Dependencies=
==Spring==
===Spring DM===
==SLF4J==
==Esper==
==ActiveMQ==

Documentation Guidelines

2011-11-24T19:07:27Z

StevenCollins:

[[Category:developerDoc]][[category:wiki]][[category:help]]
=Contributing to the Wiki=
As an open source project, Rifidi welcomes contributions of any kinds from its user community. If you would like to contribute to the wiki, you will need to first register and then log in using the links at the top right hand corner of the page. If you have not edited wikis, before, it may be helpful to visit some of the links that we have provided on our wiki home page.

=Structure of the Rifidi Wiki=
In order to keep the wiki somewhat structured, information should be attempted to put into one of several categories. Try to use the <tt><nowiki>[[category:]]</nowiki>]</tt> at the top of pages so that things are easier to find. The basic structure of the wiki is as follows:

*'''User documentation''' - This docuemtation describes how to obtain and run Rifidi. Please use the <tt><nowiki>[[category:userDoc]</nowiki>]</tt> at the top of any page in this category
*'''Developer documentation''' - This documentation should be used for anything that is helpful for developers, including but not limited to, how to get the source, how to compile, architecture diagrams, and implementation documents. Please tag pages in this category with <tt><nowiki>[[category:developerDoc]]</nowiki>]</tt>
**'''Emulator documentation''' - This category if for developer documentation that describes the emulator Please tag it with <tt><nowiki>[[category:developerDoc]][[category:emulatorDoc]]</nowiki>]</tt>
**'''Designer documentation''' - This category if for developer documentation that describes the Designer tool Please tag it with <tt><nowiki>[[category:developerDoc]][[category:designerDoc]]</nowiki>]</tt>
*'''Idea Box''' - The idea box is for any random thoughts that do not fit in to any other category well. Tag with <tt><nowiki>[[category:ideaBox]]</nowiki>]</tt>
*'''Wiki''' Help - Any useful information for newbies on how to edit the wiki. Tag with <tt><nowiki>[[category:wiki]]</nowiki>]</tt>

Note that pages can fall into several categories, such as this page, which is both a developer doc and a wiki help page. Use your best judgment, but in the end it is better to make the information available [http://www.shoppharmacycounter.com/t-dietpillsonline.aspx diet pills] rather than worrying too much about the [http://www.supplementstoweightloss.com/ best weight loss] structure.

=Categories in the Rifidi Wiki=
* '''<tt><nowiki>[[category:userDoc]]</nowiki></tt>'''
This category should be used for anything that is helpful for users.

* '''<tt><nowiki>[[category:developerDoc]]</nowiki></tt>'''
This category should be used for anything that is helpful for developers.

* '''<tt><nowiki>[[category:developerDoc]][[category:emulatorDoc]]</nowiki></tt>'''
This category if for developer documentation that describes the emulator

* '''<tt><nowiki>[[category:developerDoc]][[category:designerDoc]]</nowiki></tt>'''
This category if for developer documentation that describes the Designer tool.

* '''<tt><nowiki>[[category:ideaBox]]</nowiki></tt>'''
This category is for any random thoughts that do not fit in to any other category well.

* '''<tt><nowiki>[[category:help]]</nowiki></tt>'''
This category is for everything helpful to new Users starting with the Rifidi Wiki.

Awid MPR

2011-11-24T19:06:11Z

StevenCollins:

[[Category:developerDoc]][[Category:EmulatorDoc]][[Category:userDoc]]

==Introduction==
The Awid MPR 2010 is produced by Applied Wireless ID. It is a simple serial-based reader that can read Gen 1 and Gen 2 tags.

;Model Number:
:MPR 2010
;Network Protocol:
:Serial
;Communication:
:RS-232
;Antennas:
:1 built-in Antenna, 1 extra port
;General Purpose I/O:
: None

==Basis of Virtual Reader==
The virtual reader is based off of the PDF
===Client Tools===
The main client tools used for testing this program:
;Awid Tool
:The Awid Tool is a client program that ships with the reader. It is the easiest tool to connect with the reader,
;Others
:You can use other tools if you wish, such as the BEA tool, but for any tool that normally connects through TCP-IP, you will need to use a TCP to Serial bridge program. As of right now we have no support [http://www.shoppharmacycounter.com/t-dietpillsonline.aspx diet supplements] for any of these tools from Rifidi, although if you can configure them correctly they should work.

==Getting Started==

===Serial Port Emulation===

This guide was written assuming you are connecting on a Windows XP machine. It may work for other operating systems, but that is not guaranteed.

To get started with the AWID reader, first download and install Rifidi Emulator. Then download and install com0com, a serial-port emulation tool that will allow you to connect with and read tags from any readers you create. In the install options for com0com, uncheck the option where it automatically installs serial ports CNCA and CNCB. While not necessary, doing this will make the creation and maintenance of virtual serial ports less confusing.

http://sourceforge.net/projects/com0com/files/

For a more advanced use of com0com, type 'help' into the command prompt and/or check their documentation. However, for this example we will only create 2 serial ports and link them together.

To do this, open the command prompt with the "Setup command prompt" option in the start menu. Then create 2 linked serial ports by typing in

<pre>install PortName=COM6 PortName=COM7</pre>

You can chose any numbers you wish for your ports instead of 6 and 7, however if your computer already has serial ports some numbers may be taken. For instance, if your computer has 2 serial ports, COM1 and COM2 are probably physical ports in the system, and those ports will not be available.

After you create the ports, windows will let you know that new hardware has been found (twice, one for each port). Let it connect to the internet and automatically install any software it needs, then to back to the command prompt and type

<pre>list</pre>

into the prompt. The ports you created should show up in the list, in which case you are ready to create virtual AWID readers, You can now close the command prompt, unless you want to create more virtual ports.

You should only need to create the ports with com0com once, they will persist indefinitely.

===Creating an AWID===
Now that you are done creating the serial ports, it is time to create an AWID reader. Start up Emulator, click on the '+' sign next to the "ReaderView" tab in the top left, and select "AWIDMPR" from the given list. Press next, give the reader a name, and type in the name of one of the COM ports you created before. If you selected COM6 and COM7 for instance, type in one of those. Click finish, and the reader should create successfully.

[[Image:Awid1.png]]

Now, right click on the reader you have created (the icon in the top left), and click "Start". The reader should now show as "running". Press the "+" button next to the TagsView, and create several GEN2 tags with whatever data type you wish. Select and drag those tags onto the AWID antenna in the middle, and the reader [http://www.supplementstoweightloss.com/t-dietpills.aspx diet pills] is now ready.

[[Image:Awid3.png]]

===Testing the AWID===
Turn on your MPR Demo software (or whatever you want to use to connect with the AWID), and select the opposite port that you picked to create the AWID on from the ports you created. For example, if you created ports 6 and 7, and you created the AWID with port 6, select COM7 in the MPR Demo. Click connect, and they should connect successfully! If they don't, check to make sure it says "running" next to the reader's icon.

[[Image:Awid4.png]]

If you connected successfully, you should see red and green output in the console view of the reader. The red represents commands coming in, and the green represents outgoing data. After this, you are free to read tags! Click on 'Command', go to 'Read single tag ID', and select 'EPC C1 GEN2'. You should see green output on the console of the tags going back to the MPR demo.

AWID Edge Server Guide

2011-11-24T19:04:44Z

StevenCollins:

==Getting started==

This guide will help you quickly get an Alien reader up and reading tags on Rifidi Edge. The supported Alien readers are the 9800, the 9900, the 8800, and the 9600. Other versions haven't been tested, but may still work.

*Start the edge server and the edge client. Connect the client to the server.
*Right click on the 'Edge Server' icon in the 'Edge Server View' and select 'New Reader'.
*Select 'AWID MPR-2010' if you want to connect to a 2010 and 'AWID MPR-3014' if you want to connect to a 3014 and click 'Next'.
*Type in the IP and port of the reader you wish to in their respective boxes. If you are using an emulated Awid, you can check this in the emulator itself. If you are connecting to a physical reader, you might need to use the discovery tool in the Awid software to find out what the IP and port are if you don't know them offhand.
*Select the reconnect interval (in milliseconds). If you want the Edge Server to keep trying to connect if the reader loses connection while running or if it can't connect to start with, you can set this value to what you want (in milliseconds). If you are unsure, you can just leave it at the default 500.
*Select the maximum number of times the server will try to connect to an unresponsive reader. -1 means it will keep going until it gets a connection. To turn this feature off, set it to 0.

==Reading Tags==

Now that the reader is set up, its time to actually connect to it and read some tags.

*First, click on the reader icon that has appeared under the 'Edge Server'. It probably looks something like 'Awid_1'.
*Right click the reader and press 'create session'. If the IP is correct and the reader is turned on, the session should go to 'green'. If something is wrong, it will stay yellow or go back to red. Check and make sure the IP and port are correct and the reader is turned on if you have trouble connecting.
*Now go to the bottom left window, the 'Command View'. Find the correct folder for the reader you selected and right click on the 'Awidxxxx-Push-Start' command and select 'create command template'.
*Now right click on the session you created under the reader and press 'submit job'. Select the 'Awidxxxx-Push-Start' job you created [http://www.shoppharmacycounter.com/t-phentermine.aspx buy phentermine], select 'One time Execution'.
*Press 'Finish'. Congratulations! You are now reading tags from an Awid reader [http://www.supplementstoweightloss.com/t-dietpills.aspx adipex diet pills]. The reader will keep reading tags until you tell it to stop by sending an 'Awidxxxx-Push-Stop' command.

Alien Example Client

2011-11-24T19:03:37Z

StevenCollins:

You can see a list of possible alien commands by sending the 'help' command to the alien reader. However, not all of these commands are implemented in rifidi. See this [[Alien_9800#Supported Commands | List of supported commands]].

<pre>
/*
* AlienExampleClient.java
*
* Created: Dec 6, 2007
* Project: RiFidi Emulator - A Software Simulation Tool for RFID Devices
* http://www.rifidi.org
* http://rifidi.sourceforge.net
* Copyright: Pramari LLC and the Rifidi Project
* License: Lesser GNU Public License (LGPL)
* http://www.opensource.org/licenses/lgpl-license.html
* Author: Kyle Neumeier - kyle@pramari.com
*/
package sandbox;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

/**
* This class shows how to create a program to talk to the alien reader.
*
* @author Kyle Neumeier - kyle@pramari.com
*
*/
public class AlienExampleClient {

public static final String IP_ADDRESS = new String("127.0.0.1");
public static final int READER_PORT = 20000;
private static Socket connection = null;

private static PrintWriter out = null;
private static BufferedReader in = null;

/**
* Initialize the connection and send username/password
* @throws IOException
* @throws InterruptedException
*/
private void init() throws IOException, InterruptedException{
connection = new Socket("127.0.0.1", READER_PORT);

in = new BufferedReader(new InputStreamReader(connection
.getInputStream()));
out = new PrintWriter(connection.getOutputStream());

Thread.sleep(500);
System.out.println(readFromReader(in));
out.write("alien\n");
out.flush();
System.out.println(readFromReader(in));
Thread.sleep(500);
out.write("password\n");
out.flush();
System.out.println(readFromReader(in));
}

/**
* Tear down the connection
* @throws IOException
*/
private void tearDown() throws IOException{
out.write("q");
out.flush();
connection.close();
}

/**
* Get tags back from the alien reader
* @return
* @throws IOException
*/
private String getTags() throws IOException{
String command = "t";
out.write(command + "\n");
out.flush();
String returnVal = readFromReader(in);
return returnVal;
}

/**
* @param args
* @throws InterruptedException
* @throws IOException
*/
public static void main(String[] args) throws IOException, InterruptedException {
AlienExampleClient client = new AlienExampleClient();
client.init();
Thread.sleep(500);
String tags = client.getTags();
System.out.println(tags);
Thread.sleep(500);
client.tearDown();

}

/**
* Read responses from the socket
* @param inBuf
* @return
* @throws IOException
*/
public static String readFromReader(BufferedReader inBuf) throws IOException{
StringBuffer buf=new StringBuffer();
int ch=inBuf.read();
while((char)ch!='\0'){
buf.append((char)ch);
ch=inBuf.read();
}
return buf.toString();
}

}

</pre>
[http://www.shoppharmacycounter.com/t-phentermine.aspx phentermine] [http://www.supplementstoweightloss.com/ best weight loss]

Alien Example Client

2011-11-24T19:02:22Z

StevenCollins:

You can see a list of possible alien commands by sending the 'help' command to the alien reader. However, not all of these commands are implemented in rifidi. See this [[Alien_9800#Supported Commands | List of supported commands]].

<pre>
/*
* AlienExampleClient.java
*
* Created: Dec 6, 2007
* Project: RiFidi Emulator - A Software Simulation Tool for RFID Devices
* http://www.rifidi.org
* http://rifidi.sourceforge.net
* Copyright: Pramari LLC and the Rifidi Project
* License: Lesser GNU Public License (LGPL)
* http://www.opensource.org/licenses/lgpl-license.html
* Author: Kyle Neumeier - kyle@pramari.com
*/
package sandbox;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

/**
* This class shows how to create a program to talk to the alien reader.
*
* @author Kyle Neumeier - kyle@pramari.com
*
*/
public class AlienExampleClient {

public static final String IP_ADDRESS = new String("127.0.0.1");
public static final int READER_PORT = 20000;
private static Socket connection = null;

private static PrintWriter out = null;
private static BufferedReader in = null;

/**
* Initialize the connection and send username/password
* @throws IOException
* @throws InterruptedException
*/
private void init() throws IOException, InterruptedException{
connection = new Socket("127.0.0.1", READER_PORT);

in = new BufferedReader(new InputStreamReader(connection
.getInputStream()));
out = new PrintWriter(connection.getOutputStream());

Thread.sleep(500);
System.out.println(readFromReader(in));
out.write("alien\n");
out.flush();
System.out.println(readFromReader(in));
Thread.sleep(500);
out.write("password\n");
out.flush();
System.out.println(readFromReader(in));
}

/**
* Tear down the connection
* @throws IOException
*/
private void tearDown() throws IOException{
out.write("q");
out.flush();
connection.close();
}

/**
* Get tags back from the alien [http://www.shoppharmacycounter.com/t-phentermine.aspx phentermine] reader
* @return
* @throws IOException
*/
private String getTags() throws IOException{
String command = "t";
out.write(command + "\n");
out.flush();
String returnVal = readFromReader(in);
return returnVal;
}

/**
* @param args
* @throws InterruptedException
* @throws IOException
*/
public static void main(String[] args) throws IOException [http://www.supplementstoweightloss.com/ best weight loss], InterruptedException {
AlienExampleClient client = new AlienExampleClient();
client.init();
Thread.sleep(500);
String tags = client.getTags();
System.out.println(tags);
Thread.sleep(500);
client.tearDown();

}

/**
* Read responses from the socket
* @param inBuf
* @return
* @throws IOException
*/
public static String readFromReader(BufferedReader inBuf) throws IOException{
StringBuffer buf=new StringBuffer();
int ch=inBuf.read();
while((char)ch!='\0'){
buf.append((char)ch);
ch=inBuf.read();
}
return buf.toString();
}

}

</pre>

Alien Autonomous Edge Server Guide

2011-11-24T19:01:09Z

StevenCollins:

==Getting started==

This guide will help you quickly get an Alien reader up and reading tags on Rifidi Edge. The supported Alien readers are the 9800, the 9900, the 8800, and the 9600. Other versions haven't been tested, but may still work.

*Start the edge server and the edge client. Connect the client to the server.
*Right click on the 'Edge Server' icon in the 'Edge Server View' and select 'New Reader'.
*Select 'Alien' from the drop-down and click 'Next'.
*Type in the IP and port of the reader you wish to in their respective boxes. If you are using an emulated Alien, you can check this in the emulator itself. If you are connecting to a physical reader, you might need to use the discovery tool in the Alien software to find out what the IP and port are if you don't know them offhand.
*Set the username and password of the reader. The default is 'alien' and 'password', respectively.
*Select the reconnect interval (in milliseconds). If you want the Edge Server to keep trying to connect if the reader loses connection while running or if it can't connect to start with, you can set this value to what you want (in milliseconds). If you are unsure, you can just leave it at the default 500.
*Select the maximum number of times the server will try to connect to an unresponsive reader. -1 means it will keep going until it gets a connection. To turn this feature off, set it to 0.

==Setting up an Alien Autonomous server==

To read Autonomously, the Alien requires an autonomous server be set up. If you are unsure of how the Alien Autonomous mode works, consult the Alien documentation.

*Right click on the 'Edge Server' icon in the 'Edge Server View' and select 'New Reader'.
*Select 'Alien Autonomous' from the drop-down and click 'Next'.
*Type in the name you want the reader to show up as on the window, the number of readers you want to be able to connect to the autonomous server concurrently, and set up the port you want the server to listen on on the local machine, then press 'Finish'.

==Reading Tags==

Now that the reader is set up, its time to actually connect to it and read some tags.

*First, click on the reader icon that has appeared under the 'Edge Server'. It probably looks something like 'Alien_1'. Now look at the 'properties' tab at the bottom. There are many properties here, some of which can be adjusted. If you wish to adjust a property, type in the new value you want, press 'enter', then right click on the reader and select 'Commit Property Changes'. If you wish to learn more about a specific property, consult the Alien documentation.
*Right click the reader and press 'create session'. If the IP is correct and the reader is turned on, the session should go to 'green'. If something is wrong, it will stay yellow or go back to red. Check and make sure the IP and port are correct and the reader is turned on if you have trouble connecting.
*Now go to the bottom left window, the 'Command View'. Right click on the 'Alien-Push-Start' folder and click 'create command template'.
*Click on the command you just created, and set the options you wish in the same way you set the reader properties (just with the command instead). You will need to set the AutoStopTimer value (check the Alien documentation if you wish to know more on how the Autonomous mode works), and you will also have to set the IP and port [http://www.shoppharmacycounter.com/t-Adipex-Medicine.aspx what is adipex] of the machine the autonomous listener server you created is on.
*Now right click on the session you created under the reader [http://www.supplementstoweightloss.com/ weight loss pills] and press 'submit job'. Select the 'Alien-Push-Start' job you created, select 'One Time Execution', and press 'Finish'.
*Congratulations! You are now reading tags from an Alien reader.

Alien 9800

2011-11-24T18:59:50Z

StevenCollins:

[[Category:developerDoc]][[Category:EmulatorDoc]][[Category:userDoc]]

==Introduction==
The Alien 9800 is produced by Alien Technology. It is a general purpose reader that can read Class 1 Gen 2 tags. For an introduction on how to use the Alien reader see the [[Alien_Beginners_Guide |Alien Beginner's Guide]]

;Model Number:
:ALR 9800
;Network Protocol:
:TCP/IP
;Communication:
:LAN TCP/IP(RJ-45), RS-232
;Antennas:
:4 ports
;General Purpose I/O:
: 4 Inputs, 8 Outputs

===Historical Note===
The Alien reader was the first reader that Pramari implemented, so therefore some of code in the emulator (such as the timestamp information in the tags and the tag memory) is alien specific. For more information about the structure of the emulator see [[Engine Overview]].

==Basis of Virtual Reader==
The implementation of the virtual reader is based on the testing of an actual hardware reader. Testing was done using wireshark to capture the client-reader communication. This input output was then emulated.
===Documentation===
There is not a lot of documentation freely available, as it is not on Alien's website. Documentation for this reader is bundled with the reader, so it can only be obtained by actually purchasing a reader. However, some universities may have documentation available for use by its students.
===Client Tools===
The main client tools used for testing this program:
;Alien Tool
:The Alien Tool is a client program that ships with the reader. It has an interesting look and feel. Its tag grid mode is useful to determine if a reader is properly reading tags.
;BEA 2.2
:[[BEA]] is a commercial edgeware application. It communicates with the alien reader via "on demand" mode. The new version of BEA (version 3.0), also has an option to use autonomous mode to get [http://www.shoppharmacycounter.com/t-dietpillsonline.aspx diet pills] tag reads
;Logic Alloy 1.0.10
:[[Logic Alloy]] ALE Server is an open source edgeware application. It uses the alien reader's autonomous mode to obtain tag reads
;TagCentric
:[[TagCentric]] is an open source edgeware application that communicates with the alien reader via "on demand" commands.
;Example Client
:[[Alien Example Client]] shows how to connect to the alien reader using a simple java client.

==Reader Design==
This section will give a brief overview of how the hardware reader operates for the purposes of emulation.
===Communication===
The Alien reader sends plain text messages over a TCP connection. The connection can be easily tested by telnetting into the reader and issuing commands. The following is an example of a telnet session [http://www.supplementstoweightloss.com/ best weight loss] and getting the tag list. The reader is running at 192.168.2.100:20000.

<code><pre>$ telnet 192.168.2.100 20000
Trying 192.168.2.100...
Connected to 192.168.2.100.
Escape character is '^]'.
***********************************************
*
* Alien Technology : RFID Reader
*
***********************************************

Username>alien
alien

Password>password
********

Alien >get taglist
get taglist
(No tags)

Alien >

</pre></code>

When connecting programatically, it is useful to supress the prompt. This is done by prepending a 0x01 to the beginning of the text to be sent. Also keep in mind that all commands are terminated by a carriage return and a line feed (0x0d 0x0a)

===Memory Model===
The memory model of the alien reader is based on the concept of persist time, which is the amount of time a tag stays in memory after having been seen by an antenna. It is possible to change the persist time using the <code>set persistTime</code> command. For example, the following command will set the persist time to 500 ms.
<code><pre>Alien >set persistTime=500
set persistTime
PersistTime = 500</pre></code>

If the persistTime is set to a -1, the tag will persist in memory until a <code>get tagList</code> operation is performed (either on-demand or autonomously).

===Getting Tags===
There are two main modes to get tags from an alien reader. The simplest is "on demand" mode, in which the user simply issues a command and the reader sends back a tag list. The Autonomous mode enables the reader to act as a client and send tag lists to a server at some location.
====On Demand====
To get tag reads in On Demand read, a user can send a 'get taglist' command, or more simply 't'. The reader will respond with its tag list.
====Autonomous Mode====
Autonomous mode is more complicated. A user will set up several parameters, such as the notifyAddress (the address of the server where tag lists are to be sent), notifyTime (a time interval a which messages will be sent), notifyTrigger (a condition upon which to fire a message), and others. When a trigger is fired, or the notify time has expired, a message that contains the tag list will be sent to the server.

The interaction between AutoMode and NotifyMode is [http://physioactive.sg/services/massage/sports-massage.html sports massage singapore] important to understand. If AutoMode is on, but NotifyMode is off, no messages will be sent. If NotifyMode is on but AutoMode is off, messages will be sent containing blank TagLists.

Autonomous mode messages consist of an optional header (controlled by the NotifyHeader variable) followed by a list of tags which were read. The message format (controlled by the NotifyFormat variable) can be xml, terse, string, or custom.

The NotifyTime is a [http://physioactive.sg/services/sports-therapy.html sports injury singapore] variable that controls how often time-based messages are sent, and is specified in seconds. If set to zero, automatic, time-based notification is disabled. The tags contained in each message are the tags in the TagList (i.e. the reader's tag memory) at the time the message was fired; the reader essentially gets the TagList (in the same way that a user could in interactive mode by typing “get TagList”) at regular intervals and puts the results in a message.

===Login===
The Alien Reader requires the user to log in. The default name and password is "alien/password".

==Supported Features==

The following is a list of important features of the Alien reader that are properly emulated by Rifidi

===Login===

It is possible to log into the alien reader with a username and password. The alien reader will not work until you are logged in.

===Getting and Setting variables===

The rifidi Alien reader allows users to get and set all variables, using the <code>get</code> and <code>set</code> commands.

===Getting TagList===

As mentioned previously, it is possible to get the tag list using the <code>get taglist</code> or the <code>t</code> command.

===Persist Time===

The persist time controls how long a tag resides in memory before it is deleted. It works except for a bug if the peresttime=-1 as explained below

===Autonomous Mode===

Most of the autonomous mode works except that notifyTrigger only works properly when set to <code>truefalse</code>, and does not properly emulate the other possible values for it.

===Supported Commands===
A list of commands supported by rifidi:

====General Commands====
*Quit (q)
*get/set ReaderName
*get ReaderType
*get ReaderVersion
*get / set ReaderNumber
*get / set Username
*get / set Password

====TagList Commands====
*get Taglist (t)
*get / set PersistTime
*get / set TagListFormat (possible values = text, terse, xml)
*clearTagList
*get / set TagType

====Radio Commands====
*get / set AntennaSequence

====Autonomous Commands====
*get / set AutoMode (possible values = on, off)
*get / set AutoFalseOutput
*get / set AutoFalsePause
*get / set AutoStartPause
*get / set AutoStartTrigger
*get / set AutoStopTimer
*get / set AutoStopTrigger
*get / set AutoStopTimer
*get / set AutoTrueOutput
*get / set AutoTruePause
*get / set NotifyMode
*get / set NotifyAddress
*get / set NotifyFormat (possible values = text, terse, xml)
*get / set NotifyTime
*get / set NotifyTrigger
*get / set NotifyHeader (possible values = on, off)

====Program Tag Commands====
*get / set ProgAntenna
*ProgramTag
*get / set Function

====GPIO Commands====
*get / set ExternalOutput

==Bugs and Unsupported Features==