GPIO - Revision history

Matt: Undo revision 5891 by StevenCollins (Talk)

2012-03-05T03:37:18Z

Undo revision 5891 by StevenCollins (Talk)

StevenCollins at 19:16, 24 November 2011

2011-11-24T19:16:53Z

Matt: Reverted edits by Amesycyxa (Talk); changed back to last version by Kyle

2010-11-26T19:44:22Z

Reverted edits by Amesycyxa (Talk); changed back to last version by Kyle

Amesycyxa at 22:15, 17 November 2010

2010-11-17T22:15:45Z

Kyle at 17:57, 29 November 2007

2007-11-29T17:57:08Z

Kyle: /* Component Description */

2007-11-21T20:00:53Z

‎Component Description

Kyle at 19:54, 21 November 2007

2007-11-21T19:54:31Z

Kyle at 16:57, 21 November 2007

2007-11-21T16:57:44Z

Kyle: New page: Future site of GPIO

2007-11-20T22:45:42Z

New page: Future site of GPIO

New page

Future site of GPIO

@@ Line 16: / Line 16: @@
 #'''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 <span class="plainlinks">[http://www.shoppharmacycounter.com/t-phentermine.aspx <span style="color:black;font-weight:normal; text-decoration:none!important; background:none!important; text-decoration:none;">phentermine</span>].  The followign two examples should help you get a grasp of how the various layers involved in GPIO interact.
+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.  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]]
@@ Line 30: / Line 30: @@
 ===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 <span class="plainlinks">[http://www.supplementstoweightloss.com/t-dietpills.aspx <span style="color:black;font-weight:normal; text-decoration:none!important; background:none!important; text-decoration:none;">adipex diet pills</span>] reader client.
+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 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]]

@@ Line 16: / Line 16: @@
 #'''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.  The followign two examples should help you get a grasp of how the various layers involved in GPIO interact.
+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 <span class="plainlinks">[http://www.shoppharmacycounter.com/t-phentermine.aspx <span style="color:black;font-weight:normal; text-decoration:none!important; background:none!important; text-decoration:none;">phentermine</span>].  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]]
@@ Line 30: / Line 30: @@
 ===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 reader client.
+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 <span class="plainlinks">[http://www.supplementstoweightloss.com/t-dietpills.aspx <span style="color:black;font-weight:normal; text-decoration:none!important; background:none!important; text-decoration:none;">adipex diet pills</span>] 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]]

@@ Line 1: / Line 1: @@
 [[category:developerDoc]] [[category:EmulatorDoc]] [[category:EngineImplementation]]
->=Purpose=
+=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&amp;task=view&amp;id=14&amp;Itemid=57&amp;limit=1&amp;limitstart=1| this]] for an a picture of how it looks on the alien reader).  They are just like &quot;lines in&quot; and &quot;lines out&quot;.
+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
@@ Line 8: / Line 8: @@
 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=

@@ Line 1: / Line 1: @@
 [[category:developerDoc]] [[category:EmulatorDoc]] [[category:EngineImplementation]]
-=Purpose=
+>=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 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&amp;task=view&amp;id=14&amp;Itemid=57&amp;limit=1&amp;limitstart=1| this]] for an a picture of how it looks on the alien reader).  They are just like &quot;lines in&quot; and &quot;lines out&quot;.
 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
@@ Line 8: / Line 8: @@
 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=

@@ Line 1: / Line 1: @@
-[[category:developerDoc]] [[category:engineDoc]] [[category:EngineImplementation]]
+[[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".

@@ Line 24: / Line 24: @@
 # '''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
-# '''Notification Interface''' 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).
+# '''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 reader client.

← Older revision		Revision as of 16:57, 21 November 2007
Line 1:		Line 1:
−	~~Future site~~ of GPIO	+	=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 new radio]]
		+	==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=