by Matt Gillespie
and Highland Mary Mountain, Senior Software Engineer, Intel Corporation

Intel® Mobile Platform SDK 1.2 adds RFID functionality to the tools that developers have available for making mobile applications that target the healthcare market. Using this new RFID programming environment, developers can complete projects more easily and quickly. They also benefit from a programming interface and object model that is in common with the rest of the SDK when integrating this functionality into the core architecture of their mobile solutions.

Intel's Digital Health initiative helps to address the technology needs of healthcare providers using innovative hardware and software solutions. By implementing solutions that grow out of this initiative, hospitals and other providers stand to improve workflow efficiency and decrease operating costs. They can also decrease the prevalence of errors that can jeopardize patient wellness and introduce institutional liability.

Technology such as the use of RFID to identify patients and track items such as medications, lab samples, and capital equipment offer the opportunity for a new generation of solutions for the healthcare market. Solutions in this area typically have a long development cycle, and a high cost of entry has traditionally existed for providers. The new RFID Reader features offered in Intel® Mobile Platform SDK 1.2 enables simplified implementation of RFID into robust healthcare solutions.

This paper gives an overview of this addition to the SDK for software architects and developers, with the intention of showing how it can be applied to mobile point-of-care solutions for hospital or other institutional settings.

RFID Technology involves wireless communication between tags and readers. Standards that govern RFID communication are still emerging, which introduces a challenge to developers who want to accommodate as many diverse types of readers and tags as possible in their solutions. While communication frequency is not fixed, the majority of devices operate in the following general ranges:

Low Frequency: 125 KHz

High Frequency: 13.56 MHz

Ultra-High Frequency: 868 -870 MHz (Europe) and 902 -928 MHz (USA)

Microwave: 2.45 GHz and 5.8 GHz

The use of high-frequency communication is presently favored by healthcare solution providers, although ultra-high frequency solutions have begun to make progress into the field. That progress is likely to be accelerated by the arrival of so-called "Generation 2" ultra-high frequency tags, which typically are substantially less expensive than high-frequency tags.

Tags consist of a chip and an antenna, enclosed in a single package, and many different styles are available. One key distinction is that between active and passive tags. Passive tags are distinguished by having no internal power supply. Electrical current induced in the antenna by the incoming radio-frequency signal is sufficient to enable the CMOS integrated circuit in the tag to power up and transmit a response.

Active tags have their own internal power source. They are much more reliable than passive tags due to the ability of active tags to conduct a "session" with a reader. They are also far more effective in many environments, including water, human or animal bodies, and metal shipping containers or vehicles. Many active tags have practical ranges of hundreds of meters and a battery life of up to 10 years.

RFID readers include a wide variety of devices that are not necessarily compatible with one another at the hardware-interface level. That is, readers from different manufacturers require different hardware-interface characteristics, which presents a significant challenge to solution developers. Providing a common object model that helps to reduce the incompatibilities that underlie that challenge is one of the core capabilities of the Intel Mobile Platform SDK. Mobile RFID readers may be assumed to be attached to a laptop, tablet PC, handheld, or other device by means such as a serial port, USB, or Bluetooth* technology. In some cases, the reader may be integrated directly into such a device.

RFID solutions are emerging as a compelling replacement for current patient-identification solutions in the healthcare environment. Their chief benefit in this area is their ability to reduce inefficiencies and errors associated with alternatives such as handwritten patient wristbands and barcode-based solutions. The business opportunities and advantages associated with RFID solutions in the healthcare environment are discussed in a companion paper to this one, "RFID Simplifies Improvements to Hospital Bedside Care."

This new generation of solutions represents a clear opportunity for developers. The corresponding challenge is to provide solutions that are flexible enough to support the full range of RFID infrastructures that customer healthcare institutions and their suppliers have in place or will implement in the foreseeable future. Intel is facilitating the efforts of developers to meet that challenge with the RFID functionality that is incorporated into the Intel Mobile Platform SDK 1.2.

The Intel Mobile Platform SDK abstracts low-level programming tasks associated with creating mobile applications away from developers, allowing robust solutions to be built more easily to incorporate mobility-oriented characteristics. For example, mobilized applications must not lose the ability to support core functionality when they are disconnected from the network. Users should be able to focus on their core tasks, while the application manages network connections. Intelligent mobilized software should also tailor its operation when it is on battery power to maximize battery life.

These and other mobility goals are supported by a programming interface and object model that are common across languages and platforms, dramatically simplifying software development using a wide range of mobility-oriented functionality. Three versions of the programming interface are supported in the Intel Mobile Platform SDK: a native C++ interface, a Microsoft .NET interface, and a Java* interface. A common object model is also provided, which incorporates the following:

Classes, instances, properties, and methods. Classes represent system devices such as battery, processor, and RFID reader, as well as capabilities that include power, connectivity status, and bandwidth. The classes are instantiated using properties and methods.

Events and threshold notifications. The SDK enables applications to monitor system behavior and receive notifications when specific events occur. Thus, for example, software can respond when the device gets connected to a network or when battery charge reaches a certain level.

Collections and enumerations. Classes within the SDK allow for the discovery of all devices on the system and allow for enumeration of multiple instances of a device.

The capabilities of the Intel Mobile Platform SDK allow programmers to more easily create adaptive applications that provide a better mobile experience, allowing users to extend and expand mobile usage models. By exposing platform capabilities directly to the software developer, the SDK removes operating-system-specific dependencies. By reducing the need for creation of multiple code bases to support various platforms, it allows developers to more easily target many operating systems on a wider range of hardware, such as laptops, tablet PCs, ultra-mobile PCs, PDAs, and phones.

The RFID programming functionality of the Intel Mobile Platform SDK adds RFID readers to the set of internal system devices that are accessible using the SDK. Figure 1 shows how that capability fits into the Intel Mobile Platform SDK 1.2 functional architecture, alongside the APIs for accessing other system devices such as batteries, processors, and display adapters. A distinct benefit to developers is that integrating the RFID reader device into the system architecture in this way allows applications to interact with the RFID reader in an analogous way to other devices. Thus, adding RFID functionality into new or existing applications is no more complex than other familiar feature types.

Figure 1. Intel® Mobile Platform SDK 1.2 Functional Architecture

The SDK shields developers from the complexity of RFID reader devices. This simplicity means that developers can add RFID functionality to healthcare software products using existing skill sets.

The Intel Mobile Platform SDK 1.2 offers a range of capabilities that solution providers should consider in deciding what RFID features to incorporate into a given healthcare solution. The table below outlines discrete aspects of RFID functionality that are supported by the SDK and maps them to examples of their usefulness in a healthcare environment (the uses given here are only representative examples of the types of functionality that the SDK enables in Digital Health applications):

Note that this document follows the popular convention that "RFID reader" refers to a device that has both read and write capabilities. Moreover, most operations can be carried out either on a single tag or a group of tags simultaneously. The design of application interfaces for using RFID tags should support both models.

Considering the capabilities listed here, relative to the general capabilities and usage of a given application, application designers can consider their end-user's business needs to determine what RFID functionality would provide the most value in a given solution. The breadth of these capabilities lends itself to the addition of additional features and functionality in subsequent versions of the product, using the consistent programming environment offered by the SDK.

The new RFID Reader API within the Intel Mobile Platform SDK 1.2 dramatically simplifies the tasks associated with building RFID-enabled user applications. Without the benefit of the SDK, it is necessary for developers to use serial calls to RFID reader device drivers. This process is very complex, cumbersome, and time-consuming, and it requires skill sets that are not common among many programmers.

Moreover, traditional solutions are device-dependent, so it is necessary to provide low-level programming that can interface separately with each supported RFID reader device. Protocols for communicating with readers typically specify only the data-communication layer, with the hardware-interface layer being specific to each device. Since there is so much variation among devices, this device specificity represents a substantial impediment to solution development.

Using the Intel Mobile Platform SDK, on the other hand, it is far simpler to incorporate the functionality to interface with a variety of RFID readers from different manufacturers. The properties, methods, and events associated with the RFIDReader object are delineated in the table below:

This object-oriented programming model makes it relatively simple to control the RFID reader device attached to the target system, enabling the developer to easily add software features to carry out simple or complex tasks. The following C# code, for example, could be used to integrate the functionality to read data to an RFID tag embedded within a patient wristband:

private void btnReadUserData_Click(object sender, System.EventArgs e)
{
     // C# code specific to form and textbox operation     
this.Cursor = Cursors.WaitCursor; 
/// Read User Data – Wristband form factor tag
     if(!reader.Open()) 
{
    MessageBox.Show("Failed to open RFID Reader connection"); 
}
   else 
{
     ArrayList tagData = new ArrayList();     
if(!reader.ReadUserData(tagData)) 
{
     MessageBox.Show("ReadUserData method failed"); 
}
     else 
{
     txtReadUserData.Text = ByteArrayListToString(tagData); 
}
     reader.Close(); 
}
     // C# code specific to form and textbox operation 
this.Cursor = Cursors.Default; 
}

Additional coding samples are included in an appendix to this document. Typical operations related to mana ging data on RFID tags can be accomplished with a similar degree of simplicity. For a comprehensive reference about writing software using the SDK, see the Intel Mobile Platform SDK Programmer's Guide, which is available from the product Web site.

Digital Health, or the incorporation of advanced computing technologies into the healthcare setting, is an important area of opportunity for software providers in the coming years. RFID technology holds great promise to differentiate next-generation patient-identification and related solutions within the market. For developers of healthcare solutions who wish to incorporate RFID into their software, the Intel Mobile Platform SDK offers the ability to simplify the process while improving the robustness of the resulting product.

Organizations and individuals interested in evaluating the Intel Mobile Platform SDK should download an evaluation copy¹ for a free 60-day trial.

The following materials provide a point of departure for further research on this topic:

• Intel® Mobile Platform Software Development Kit product information page provides exhaustive technical detail, as well as links for free evaluation or purchase of the product.
• Healthcare Research and Solutions from Intel are helping to accelerate improvements in healthcare quality by delivering technology solutions to enhance health and wellness.
• RFID and Intel®-based Solutions gives an overview of Intel research into standards-based RFID solutions with academic and industry leaders.
• Intel Mobile Developer Community provides links to technical documentation for mobilizing software applications, as well as community forums and blogs on mobility topics.

¹ RFID functionality is available from the Intel Mobile Platform SDK starting with version 1.2. Note that the SDK supports only the Skyetek M1 module directly; other RFID readers require a DLL to be built that services the Intel Mobile Platform SDK API.

* Note: Intel® Mobile Platform SDK 1.2 ONLY provides binding interface, property and methods for RFID. There's no default implementation of this interface. Users need to define their own RFID instance provider based on RFID specification.

Matt Gillespie is an independent technical author and editor working out of the Chicago area and specializing in emerging hardware and software technologies. Before going into business for himself, Matt developed training for software developers at Intel Corporation and worked in Internet Technical Services at California Federal Bank. He spent his early years as a writer and editor in the fields of financial publishing and neuroscience.

Highland Mary Mountain is a Senior Software Engineer at Intel Corporation’s Chandler Arizona site (Phoenix area). She has held leadership positions in Product Development, R&D and also participated in the W3C XMLP (SOAP) Working Group. Recently, her technical focus has been HF/UHF RFID Reader technologies and related APIs. In her earlier days, Highland Mary earned an MS in Computer Science from Rochester Institute of Technology in Rochester, NY.

The following coding samples give examples of how the Intel Mobile Platform SDK 1.2 can be used to add RFID functionality within C# applications. The rudimentary interface shown in Figure 2 illustrates how mainstream developers can use the Intel Mobile Platform SDK API to pass information to and from the RFID reader with relative ease. Use of the API enables them to create this functionality without a specialized skill set, by abstracting RFID-specific coding tasks away from the larger development effort.

Figure 2. A rudimentary interface shows how developers can create read/write
functionality for RFID tags using the Intel® Mobile Platform SDK

Instantiate the IMPSDK RFID Reader Instance

private void InitReader() 
{
/// Instantiate the IMPSDK RFID Reader Instance in .Net C#
RfidReaderClass readerClass = new RfidReaderClass(); 
RfidReaderCollection readerCollection = (RfidReaderCollection)readerClass.GetInstances(); 
if(!readerCollection.HasNext()) 
{
MessageBox.Show("No RFID Readers found"); 
}
else 
{
reader = (RfidReaderInstance)readerCollection.Next(); 
}
}

Obtain RFID Reader Property Information for Status Bar

private void InitReaderStatus(StatusBarPanel rfidStatus) 
{
/// Obtain RFID Reader Property Information for Status Bar 
if(!reader.Open()) 
{
MessageBox.Show("Failed to open RFID Reader connection"); 
}
else 
{
rfidStatus.Text = reader.Manufacturer.GetValue() + " : " + reader.Name.GetValue(); rfidStatus.ToolTipText = 
"BaudRate = " + reader.BaudRate.GetValue().ToString() 
+ " 
Serial Port = " + reader.SerialPort.GetValue().ToString() 
+ " 
Serial Number = " + reader.SerialNumber.GetValue(); 
reader.Close(); 
}

Read Tag IDs and show them in a text box

private void btnReadTagIDs_Click(object sender, System.EventArgs e) 
{
// C# code specific to form and textbox operation 
this.Cursor = Cursors.WaitCursor; 
/// Read Tag IDs and show them in first text box 
if(!reader.Open()) 
{
MessageBox.Show("Failed to open RFID Reader connection"); 
}
Else 
{
ArrayList tags = new ArrayList(); 
if(!reader.ReadTags(1000, tags)) 
{
MessageBox.Show("ReadTags method failed"); 
}
txtReadTagIDs.Text = "";     
foreach(TagInfo ti in tags) 
{
if(txtReadTagIDs.Text == "") 
{
txtReadTagIDs.Text = ti.TagId; 
}
else 
{
txtReadTagIDs.Text = 
txtReadTagIDs.Text + " : " + ti.TagId; 
} 
} 
reader.Close(); 
}
// C# code specific to form and textbox operation 
this.Cursor = Cursors.Default; 
}

Write User Data to a Patient Wristband Tag

private void btnWriteUserData_Click(object sender, System.EventArgs e) 
{
// C# code specific to form and textbox operation 
this.Cursor = Cursors.WaitCursor; 
/// Write User Data – Wristband form factor tag 
if(!reader.Open()) 
{
MessageBox.Show("Failed to open RFID Reader connection"); 
}
else 
{
ArrayList data = StringToByteArrayList(txtWriteUserData.Text); 
if(!reader.WriteUserData(data))
{
MessageBox.Show("WriteUserData method failed"); 
}
reader.Close(); 
}
// C# code specific to form and textbox operation 
this.Cursor = Cursors.Default; 
}

Read User Data to a Patient Wristband Tag

private void bt 
nReadUserData_Click(object sender, System.EventArgs e) 
{
// C# code specific to form and textbox operation 
this.Cursor = Cursors.WaitCursor; 
/// Read User Data – Wristband form factor tag 
if(!reader.Open()) 
{
MessageBox.Show("Failed to open RFID Reader connection"); 
}
else 
{
ArrayList tagData = new ArrayList(); 
if(!reader.ReadUserData(tagData)) 
{
MessageBox.Show("ReadUserData method failed"); 
}
else 
{
txtReadUserData.Text = ByteArrayListToString(tagData); 
}
reader.Close(); 
}
// C# code specific to form and textbox operation 
this.Cursor = Cursors.Default; 
}

Comments (5)

March 10, 2009 2:34 PM PDT Nicolas Nicolaou

am trying to run the program on references i attached the correct dll file (rfidCRL12).Then i initialized . using Intel.Mobile.Rfid; and i have the same error many times, for example at this line : RfidReaderClass readerClass = new RfidReaderClass(); i have that error Error 1 The type 'Intel.Mobile.Base.ClassObject' is defined in an assembly that is not referenced. You must add a reference to assembly 'IntelMobileCLR12, Version=1.2.0.0, Culture=neutral, PublicKeyToken=98d92f86899e0d74'.

March 11, 2009 9:22 PM PDT feng

from the error information, it seem that IntelMobileCLR12 did not include in your run time path. please find the IntelMobileCLR12.dll and put it into the same folder of the rfidCLR12.dll. please also refer the sample code : Samples\Win32\CLR\RfidSample

March 23, 2009 3:52 PM PDT Nicolas Nicolaou

now the program it works. I have a usb rfid with “Usb.Harve.Sys for RFID Intel MAC” chip.Is it possible to work with the specific libraries? If is not is there any other libraries?

June 10, 2009 6:56 AM PDT Pasquale Paola

I don't find RfidReaderClass into the intel SDK 1.3...where is?

June 10, 2009 8:29 PM PDT Bin Zhu

RfidReaderClass is defined in binding lier of C++/.NET/Java API. You need to have the RFID plug-in integrated in the SDK to get it works. Please refer to the PDK (Provider Development Kits) on how to add a device support like the usb rfid.

Trackbacks (0)

Leave a comment