HPE Edgeline EL300 User manual

HPE Edgeline EL300 Converged Edge
System Daughter Card Getting Started
Guide
Part Number: P12926-001
Published: December 2018
Edition: 1
Abstract
This document is intended to help users get started with the HPE Edgeline EL300 daughter
cards. The daughter cards described in this document are CAN bus A/B/FD2.0,
RS232/422/485, 8 bit configurable GPIO, and 1GB Ethernet with Time Sensitive Network
support. For more information on these daughter cards, refer to the HPE Edgeline EL300
Converged Edge System Setup and Configuration guide. C and Python code examples for
Windows and Linux are presented. These examples can be used as a base to communicate
quickly with the daughter cards. These examples are not complete code modules and should
be used for reference only. For error checking and bit manipulation, users should refer to
appropriate documents based on their individual requirements.

© Copyright 2018 Hewlett Packard Enterprise Development LP
Notices
The information contained herein is subject to change without notice. The only warranties for Hewlett
Packard Enterprise products and services are set forth in the express warranty statements accompanying
such products and services. Nothing herein should be construed as constituting an additional warranty.
Hewlett Packard Enterprise shall not be liable for technical or editorial errors or omissions contained
herein.
Confidential computer software. Valid license from Hewlett Packard Enterprise required for possession,
use, or copying. Consistent with FAR 12.211 and 12.212, Commercial Computer Software, Computer
Software Documentation, and Technical Data for Commercial Items are licensed to the U.S. Government
under vendor's standard commercial license.
Links to third-party websites take you outside the Hewlett Packard Enterprise website. Hewlett Packard
Enterprise has no control over and is not responsible for information outside the Hewlett Packard
Enterprise website.

Contents
2x CAN Bus A/B/FD 2.0 - Glavanically Isolated Daughter Card..........4
Overview....................................................................................................................................... 4
Configure the Card Using iSM...................................................................................................... 4
CAN Bus Programming.................................................................................................................4
Windows.............................................................................................................................4
Linux.................................................................................................................................11
2x RS232/422/485 Glavanically Isolated (up to 12 Mbps in RS
422/485) Daughter Card........................................................................ 16
Overview..................................................................................................................................... 16
Configure the Card Using iSM.................................................................................................... 16
Software Example.......................................................................................................................17
8 Bit Configurable GPIO Daughter Card (with 12 pin Phoenix
Connector)............................................................................................. 19
Overview..................................................................................................................................... 19
Configure the Card Using iSM.................................................................................................... 20
Keeping the system in sync........................................................................................................ 20
Code Examples...........................................................................................................................22
4x 1GB Ethernet with TSN Support Daughter Card........................... 26
Overview..................................................................................................................................... 26
TSN Daughter Card.................................................................................................................... 26
Configuring the TSN Card Using iSM......................................................................................... 26
Enabling the OS Support............................................................................................................ 27
Configuration Example................................................................................................................27
Software Example.......................................................................................................................29
Websites................................................................................................ 31
Support and other resources...............................................................32
Accessing Hewlett Packard Enterprise Support......................................................................... 32
Accessing updates......................................................................................................................32
Customer self repair....................................................................................................................33
Remote support.......................................................................................................................... 33
Warranty information...................................................................................................................33
Regulatory information................................................................................................................34
Documentation feedback............................................................................................................ 34
Appendix A............................................................................................ 35
3

2x CAN Bus A/B/FD 2.0 - Glavanically Isolated
Daughter Card
Overview
HPE implemented a two channel CAN bus that communicates through a single serial port. Each channel
is associated with a DE-9 (commonly referred to as "DB-9") connection on the daughter card. All
communication is done through the single serial port and each channel is individually addressed through
the CAN protocol. A number of CAN commands have been implemented to allow CAN communication.
These commands are described in Appendix A of this document.
Configure the Card Using iSM
The Integrated System Manager (iSM) provides a facility for changing the modes of the card. The only
option available involves enabling or disabling termination of the CAN bus.
CAN Bus Programming
There are several programming languages that can interact with the HPE CAN bus. The following
programming examples use C and Python to demonstrate how the interaction works and are not
necessarily complete.
Windows
Before programming the CAN serial port on Windows, the correct COM port for the adapter must be
determined. To do this, perform the following steps:
Procedure
1. Start Windows Device Manager and click Ports.
2. Choose a COM port, and then right-click Properties.
4 2x CAN Bus A/B/FD 2.0 - Glavanically Isolated Daughter Card

3. Select the Details tab.
a. Under the Property drop-down menu, select Device instance path.
b. If the Value contains USB_CAN_FD_APPLICATION, then use this COM port as the CAN Bus
serial port.
2x CAN Bus A/B/FD 2.0 - Glavanically Isolated Daughter Card 5

4. If the CAN Bus port is not yet discovered, repeat steps 2 and 3 until the CAN Bus port is located using
Property > Value > USB_CAN_FD_APPLICATION.
C Language
When using the C language in Windows, the HPE CAN bus serial port is opened and written to as a file.
A program can communicate to the CAN bus serial port by opening the port as a file and then reading
and writing to that port. This is done using the Windows file APIs. The APIs needed are CreateFile,
WriteFile, ReadFile, and CloseFile. Ensure that errors are checked and the device error flag is
cleared between each operation by using the CleanCommError API.
Read SW Version Command
The Read SW Version command, described in Appendix A, will be used as an example of writing to and
reading from the HPE CAN bus serial port. Serial communication is sent one single bit at a time between
a transmitter and receiver. In the Read SW Version command, the specific command must be written to
the serial port and, after the command has executed, the specific response must be read from the serial
port.
Writing to the CAN Bus Serial Port
According to Appendix A of this document, the Read SW Version command involves sending a
command of 0xFF 0x00 0xC0. To accomplish this, perform the following steps:
62x CAN Bus A/B/FD 2.0 - Glavanically Isolated Daughter Card

Prerequisites
CAN Bus COM port identified - Determine Windows COM Port
Procedure
1. Open the COM port as a Windows file.
char comPort[] = "COM4";
HANDLE serialPort = CreateFileA(comPort,
GENERIC_READ | GENERIC_WRITE,
0,
0,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
2. Clear the communication error, and then get information regarding the current status of the device.
COMSTAT comStat;
DWORD errors;
ClearCommError(serialPort,
&errors,
&comStat);
3. Write command data to the port.
char data[] = { 0xFF, 0x00, 0xC0 }; //Bytes to Get Version
DWORD bytesWritten = 0;
DWORD bytestoWrite = 3;
WriteFile(serialPort,
data,
bytesToWrite,
&bytesWritten,
NULL);
4. Check the bytesWritten parameter to ensure that the correct number of bytes were written.
Reading from the CAN Bus Serial Port
After writing the command bytes to the serial port, as demonstrated in Writing to the CAN Bus, the serial
port is read to receive the command response. According to Appendix A, the command response from
the Read SW Version command is: 0xFF 0x00 0xC0 0xmm 0xmm 0xvv0xvv, where 0xmm 0xmm is the
two byte major version number and 0xvv 0xvv is the two byte minor version.
Prerequisites
• CAN Bus COM port identified - Determine Windows COM Port
• Opened file handle to the serial port
• Read SW Version command bytes written to serial port
2x CAN Bus A/B/FD 2.0 - Glavanically Isolated Daughter Card 7

Procedure
1. Clear the communication error and, then get information regarding the status of the device.
COMSTAT comStat;
DWORD errors;
ClearCommError(serialPort,
&errors,
&comStat);
2. The COMSTAT data structure contains information regarding the status of the device.
3. comStat.cbInQue contains the number of bytes received by the serial port. Use the cbInQue
information to read the number of bytes from the device.
for (DWORD index = 0;
index < comStat.cbInQue;
++index)
{
ReadFile(serialPort,
inBuffer + index,
1,
&bytesRead,
NULL);
}
4. To retrieve the version, print out the fourth and sixth byte.
printf("Version is: '%d.%d'\n",
inBuffer[4],
inBuffer[6]);
Communicating with a Specific CAN Bus Channel
Each DE-9 on the front of the HPE EL300 CAN bus daughter card represents an individual CAN bus
channel. In the CAN bus commands, described in Appendix A, the channel number is represented by a
byte: channel 0 (left DE-9) is 0x00 and channel 1 (right DE-9) is 0x01. The following code demonstrates
how to write data from channel 0 and read data from channel 1.
Prerequisites
• CAN Bus COM port should be identified
• Serial cable connected from the left DE-9 to the right DE-9
• Both ports termination is set to Enabled using the iSM described above
Procedure
1. Open a port as a Windows file.
char comPort[] = "COM4";
HANDLE serialPort = CreateFileA(comPort,
GENERIC_READ | GENERIC_WRITE,
0,
0,
OPEN_EXISTING,
82x CAN Bus A/B/FD 2.0 - Glavanically Isolated Daughter Card

FILE_ATTRIBUTE_NORMAL,
NULL);
2. Clear the communication port.
COMSTAT comStat;
DWORD errors;
ClearCommError(serialPort,
&errors,
&comStat);
3. Enable channel 0.
From Appendix A, Enable or Disable CAN Module command is 0xFF 0x00 0xcc 0xoo, where
0xcc is the channel number and 0xoo is enable (0x01) or disable(0x00).
unsigned char data[] = { 0xFF, 0x00, 0x01, 0x01 };
DWORD bytesWritten(0);
DWORD bytestoWrite(strlen((char*)data));
WriteFile(serialPort,
data,
bytestoWrite,
&bytesWritten,
NULL);
4. Ensure that the correct number of bytes were written with the bytesWritten parameter.
5. Clear the communication port, and then check for errors.
COMSTAT comStat;
DWORD errors;
ClearCommError(serialPort,
&errors,
&comStat);
6. Enable channel 1.
unsigned char data[] = { 0xFF, 0x01, 0x01, 0x01 };
DWORD bytesWritten(0);
DWORD bytestoWrite(strlen((char*)data));
WriteFile(serialPort,
data,
bytestoWrite,
&bytesWritten,
NULL);
7. Clear the communication port, and then check for errors.
COMSTAT comStat;
DWORD errors;
ClearCommError(serialPort,
&errors,
&comStat);
8. Write data from channel 0 to channel 1.
2x CAN Bus A/B/FD 2.0 - Glavanically Isolated Daughter Card 9

The CAN bus command to send data from a host to a device is, Send FD Data - Host to Device
(command 0x05), with an 8 byte data payload of 0xDE, 0xAD, 0xBE, 0xEF.
The second byte represents the write-from channel number: channel 0 for this example.
char moreData[] = {0xFF,0x00,0x05,0x00,0x08,0x00,0x00,0x00,0x01,0xDE,0xAD,0xBE,
0xEF};
bytesRead = strlen(moreData);
WriteFile(serialPort,
moreData,
bytesRead,
&bytesWritten,
NULL);
9. Clear the communication port, and then check for errors.
COMSTAT comStat;
DWORD errors;
ClearCommError(serialPort,
&errors,
&comStat);
10. Data must be read from the port.
Check for something to read using the comStat command.
if (comStat.cbInQue <= 0)
{
printf(“Nothing to read\n”);
}
11. Read from the port.
ReadFile(serialPort,
inBuffer,
comStat.cbInQue,
&bytesRead,
NULL);
12. Clear the communication port, and then check for errors.
COMSTAT comStat;
DWORD errors
ClearCommError(serialPort, &errors, &comStat);
13. Check the message format.
//check the message format
if (inBuffer[0] == 0xFF)
{
//this is a can bus message
//what channel
if (inBuffer[1] == 0x00)
{
//channel 0
}
else
{
10 2x CAN Bus A/B/FD 2.0 - Glavanically Isolated Daughter Card

//channel 1
}
if (inBuffer[2] == 0x08)
{
//get message length
}
}
NOTE: When sending the 0xB1 command (Request to Reset Device), it will cause the COM port
number to change to a different port number supplied by Windows. This causes all the hard-coded
port numbers to be incorrect. Please check the COM port number after each reset.
Linux
C Language Example
When using the C language in Linux, the HPE CAN bus serial port is opened and written to as a file. The
termios structure is used to set up the serial port.
When using the Read SW Version command, bytes will demonstrate how to view and edit the serial port.
The various other commands and responses are explained in Appendix A of this document.
The following code block explains how to open the serial port using the device path:
char* fileName="/dev/ttyACM0";
int fd = -1;
fd = open(fileName,O_RDWR | O_NOCTTY | O_SYNC);
if (-1 == fd)
{
printf("Open failed\n");
}
The following code block explains how to set up the serial port:
struct termios SerialPortSettings; //declare termios structure
memset(&SerialPortSettings, 0, sizeof SerialPortSettings); //clear structure
tcgetattr(fd, &SerialPortSettings); //read current attributes
cfsetispeed(&SerialPortSettings, B115200); //set input speed
cfsetospeed(&SerialPortSettings, B115200); //set output speed
SerialPortSettings.c_cflag &= ~PARENB; //not using parity bit
SerialPortSettings.c_cflag &= ~CSTOPB; //not using stop bits
SerialPortSettings.c_cflag &= ~CSIZE; //clear all sizes
SerialPortSettings.c_cflag |= CS8; //set 8 bit byte
SerialPortSettings.c_cflag &= ~CRTSCTS; //no HW flow control
SerialPortSettings.c_cflag &= ~(ICANON | ECHO | ECHOE | ISIG); //no canonical, echo, echoe, or signals
SerialPortSettings.c_cflag |= CREAD | CLOCAL; //enable receiver and ignore modem control
SerialPortSettings.c_cc[VMIN] = 1; //set min chars to 1
SerialPortSettings.c_cc[VTIME] = 5; //set timeout to 5 deciseconds
cfmakeraw(&SerialPortSettings); //set RAW mode
tcflush(fd, TCIFLUSH); //flush input
tcsetattr(fd, TCSANOW, &SerialPortSettings); //set the attributes
The following code block explains how to use the Read SW Version command to edit the serial port.
char GetVersionCommand[] = {0xFF,0x00,0xC0};
size_t bytesToWrite = 3;
int wlen = write(fd, GetVersionCommand, bytesToWrite);
if (-1 == wlen)
{
printf("ERROR - error is: %d\n", errno);
}
2x CAN Bus A/B/FD 2.0 - Glavanically Isolated Daughter Card 11

The following code block explains how to view the serial port:
unsigned char buffer[255];
memset(buffer, '\0', sizeof buffer);
int bytesRead = 0;
bytesRead = read(fd, &buffer, 255);
Return codes should always be checked for errors. If there are no errors, assign the 5th and 7th bytes as
the version number based on the command response described in Appendix A. The following code block
explains how to assign the version number:
if (bytesRead < 0)
{
printf("read:ERROR - error is: %d\n",errno);
}
else if (bytesRead == 0)
{
pintf("read nothing\n");
}
else
{
printf("version is: %d.%d\n", buffer[4], buffer[6]);
}
Loopback
View and edit a specific channel
Inside the serial port, there are two individual channels. Each channel represents a different CAN
channel. Each CAN channel is associated with a DE-9 connection to the CAN bus daughter card in
EL300. Refer to Appendix A to learn more about the commands that are used to view and edit each
channel. In these commands, a channel number is represented by a byte. That is, channel zero is
represented as 0x00 and channel 1 is represented as 0x01.
To learn how to write data from channel 0 and read it from channel 1, review the following code samples.
The following code block explains how to open the port using the device path:
char* fileName="/dev/ttyACM0";
int fd = -1;
fd = open(fileName, O_RDWR | O_NOCTTY | O_SYNC);
if (-1 == fd)
{
printf("Open failed\n");
}
The following code block explains how to set up the serial port:
struct termios
SerialPortSettings; //
declare termios structure
memset(&SerialPortSettings, 0, sizeof SerialPortSettings); //clear structure
tcgetattr(fd, &SerialPortSettings); //read current attributes
cfsetispeed(&SerialPortSettings, B115200); //set input speed
cfsetospeed(&SerialPortSettings, B115200); //set output speed
SerialPortSettings.c_cflag &= ~PARENB; //not using parity bit
SerialPortSettings.c_cflag &= ~CSTOPB; //not using stop bits
SerialPortSettings.c_cflag &= ~CSIZE; //clear all sizes
SerialPortSettings.c_cflag |= CS8; //set 8 bit byte
SerialPortSettings.c_cflag &= ~CRTSCTS; //no HW flow control
SerialPortSettings.c_cflag &= ~(ICANON | ECHO | ECHOE | ISIG); //no canonical, echo, echoe, or signals
SerialPortSettings.c_cflag |= CREAD | CLOCAL; //enable receiver and ignore modem control
SerialPortSettings.c_cc[VMIN] = 1; //set min chars to 1
SerialPortSettings.c_cc[VTIME] = 5; //set timeout to 5 deciseconds
12 2x CAN Bus A/B/FD 2.0 - Glavanically Isolated Daughter Card

cfmakeraw(&SerialPortSettings); //set RAW mode
tcflush(fd, TCIFLUSH); //flush input
tcsetattr(fd, TCSANOW, &SerialPortSettings); //set the attributes
The following code block explains how to enable channel 0:
char data[] = { 0xFF, 0x00, 0x01, 0x01 };
size_t bytesToWrite = 4;
int wlen = write(serialPort, data, bytesToWrite);
if (-1 == wlen)
{
printf("ERROR: enabling channel 0 - error is: %d\n", errno);
}
If there is no response to this command, check the wlen value.
The following code block explains how to enable channel 1:
char data[] = { 0xFF, 0x00, 0x01, 0x01 };
size_t bytesToWrite = 4;
int wlen = write(serialPort, data, bytesToWrite);
if (-1 == wlen)
{
printf("ERROR: enabling channel 0 - error is: %d\n", errno);
}
If there is no response to this command, check the wlen value.
The following code block explains how to write data from channel 0 to channel 1:
unsigned char moreData[] = { 0xFF, 0x01, 0x05, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0xDE,
0xAD, 0xBE, 0xEF };
bytesToWrite = strlen((char*)moreData);
wlen = write(serialPort, moreData, 13);
if (-1 == wlen)
{
printf("ERROR: writing data - error is: %d\n", errno);
}
In this code example, the FD data is sent through 0x05 with a 4 byte data payload of 0xDE, 0xAD,
0xBE, 0xEF.
NOTE: In this code example, the second byte is the channel. This channel is sent along with channel 0
defined, so it is going out on channel 0.
The following code block explains how to read data from the port:
unsigned char inBuffer[255];
memset(inBuffer, '\0', sizeof inBuffer);
int bytesRead = 0;
int index = 0;
for (index = 0; index < 13; ++index)
{
bytesRead = read(serialPort, &inBuffer[index], 1);
}
The following is the code example for checking and writing the data:
//check the message format
if ((inBuffer[0] == 0xFF) &&
(inBuffer[1] == 0x00) &&
(inBuffer[2] == 0x08))
2x CAN Bus A/B/FD 2.0 - Glavanically Isolated Daughter Card 13

{
for (index = 8; index < 13; ++index)
{
printf("Byte[%d] is: %x\n", index, inBuffer[index]);
}
}
After executing all the commands, the code to close the port is as follows:
close(serialPort);
Programming with Python
Prerequisites
In Python, serial communication is done by a serial module named pyserial. To accomplish this, download
the pyserial installer from the web and use the installer.
A serial class is instantiated with the pyserial module. The module is then used to communicate with the
CAN bus serial port using simple read and write commands.
Writing to CAN Bus Serial Port
Prerequisites
CAN Bus COM port identified - Determine Windows COM Port
Procedure
1. Import the serial module.
import serial
2. Instantiate a serial class.
port="/dev/ttyACM0
ser = serial.Serial(port=port,
baudrate=115200,
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_ONE,
bytesize=serial.EIGHTBITS)
3. Set up the packet (for version the command is 0xFF, 0x00, 0xC0).
packet="FF00C0"
4. Write to the serial port.
ser.write(bytearray.fromhex(packet))
5. The code in step 4 sends the bytes that represent the Read SW Version command to the port. To get
the information back, the port must be read.
Reading from Can Bus Serial Port
The code demonstrated in Writing to Can Bus Serial Port sends bytes represented by the Read SW
Version command to the serial port. To get the information back, the port must be read.
Referring to the Read SW Version command in Appendix A, there is a 7 byte response. Each of these
bytes will be read into an array, and then parsed for the version number.
14 2x CAN Bus A/B/FD 2.0 - Glavanically Isolated Daughter Card

Procedure
1. Read 7 bytes from the port.
for index in range(7):
for byte in ser.read():
mybyte = "%02X" % byte
line.append(mybyte.lower())
2. Pull out the major and minor versions, and then print.
major = int(''.join(line[3:5]),16)
minor = int(''.join(line[5:7]),16)
version = "%s.%s" % (major,minor)
print("Version is %s" % version)
2x CAN Bus A/B/FD 2.0 - Glavanically Isolated Daughter Card 15

2x RS232/422/485 Glavanically Isolated (up to
12 Mbps in RS 422/485) Daughter Card
Overview
This section describes how to use the serial daughter card using code examples. It also describes the
basic MODBUS RTU functionality over serial and leverages Libmobus, a common Open Source Library,
to help in understanding the fundamental methods. The code examples used in this chapter are tested on
CentOS 7.5.
In addition, this section includes the following:
• Main components of the daughter card and their configuration
• Software tools, components, and libraries required to compile the code
• Compilation steps using LibModbus
• Main methods and software execution
Configure the Card Using iSM
The iSM provides a facility for changing the modes of the card. The options include the RS485 mode and
setting the termination required for the RS422 and RS485 modes.
16 2x RS232/422/485 Glavanically Isolated (up to 12 Mbps in RS 422/485) Daughter Card

Software Example
This section describes how the MODBUS communicates using the Libmodus open source library from
http://libmodbus.org.
As this example is done on Centos 7.5, a few changes could be made to this example to make it work on
other platforms like GNU or Linux.
Getting the Tools
Download and install the necessary packages required for compiling the example and Libmodbus. The
primary components required are:
• The GCC Compiler (gcc)
• The Git revision control tool (git)
• The Autoconf configuration tool (autoconf)
• The Automake Make tool (automake)
• The Libtool library resolution tool (libtool)
Getting the Packages
In the Shell command prompt, execute the following code to install the compiler, gcc:
sudo yum -y install gcc
In the Shell command prompt, execute the following code to install the version control tool, git:
sudo yum -y install git
In the Shell command prompt, execute the following code to install the version control tool, autoconf:
sudo yum -y install autoconf
In the Shell command prompt, execute the following code to install the version control tool, automake:
sudo yum -y install automake
In the Shell command prompt, execute the following code to install the version control tool, libtool:
sudo yum -y install libtool
Getting the Software
After downloading the software tools, download the Libmodbus library from its Github.com repository.
In the Shell command prompt, execute the following code to download the actual software:
git clone https://github.com/stephane/libmodbus.git
NOTE: This shall clone (i.e. download) the software to a directory named 'libmodbus'. To use a different
directory name, add the target directory name as an additional argument to the execution arguments.
Compiling the Libmodbus Library
To compile the Libmodbus library, perform the following steps:
1. Create a configuration script using the automated generation script, autogen.sh.
2. Execute the configuration script, configure, to generate a Make file.
3. Use the make install command to execute gcc and create the installer.
2x RS232/422/485 Glavanically Isolated (up to 12 Mbps in RS 422/485) Daughter Card 17

4. Use the prefix option on the configure command to change the installation directory:
./configure --prefix-/usr/local/
5. Verify the installation with example MODBUS traffic.
To verify the installation, loopback the interfaces with a NULLMODEM serial cable. The following expects
to separate terminals.
On Terminal 1
1. Execute the following command to move into the test directory:
cd tests
2. Execute the following command to compile the example software:
gcc random-test-server.c -o random-test-server `pkg-config
--libs --cflags libmodbus`
3. Execute the following to start the random-test-server:
./random-test-server
On Terminal 2
1. Execute the following command to move into the test directory:
cd tests
2. Execute the following command to compile the example software:
gcc random-test-client.c -o random-test-client `pkg-config
--libs --cflags libmodbus`
3. Execute the following to start the random-test-server:
./random-test-client|grep Test
The usage and output of the above command is as follows:
[root@serial1 tests]# ./random-test-client|grep Test
Test: SUCCESS
18 2x RS232/422/485 Glavanically Isolated (up to 12 Mbps in RS 422/485) Daughter Card

8 Bit Configurable GPIO Daughter Card (with
12 pin Phoenix Connector)
Overview
The HPE EL300 DIO daughter card adds 8 DIO ports for use. Each of the ports is isolated and thus
allowed to be designated as an input or output. These DIO ports are available through a Phoenix style 12
pin connector. The following illustration details how each port is connected:
Figure 1: 12 pin connector wire connections
Communication to these ports are accomplished through the I2C protocol. This is a serial protocol that is
popular and easy to use. It uses a single master that can have multiple slaves. When using this protocol,
the application has access to internal registers for interacting with the DIO. The command byte is
described below:
Command Byte Register Protocol
0x00 Input Port Register Read byte
0x01 Output Port Register Read/write
0x02 Polarity Inversion Register Read/write
0x03 Configuration Register Read/write
The input port register (command byte 0x00) reflects the incoming logic levels and only acts on the read
operation. The Output port register (command byte 0x01) shows the outgoing logic levels of the pins
8 Bit Configurable GPIO Daughter Card (with 12 pin Phoenix Connector) 19

defined as outputs. The Polarity Inversion Register (command byte 0x02) allows polarity inversion of pins
defined as inputs by the configuration register. The configuration register (command byte 0x03)
configures the directions of the I/O pins. Each of these registers are 8 bits in length, with each bit
corresponding to one of the 8 DIO ports.
Only the read protocols will go to the Input Port Register. The read and write protocols will go to the
Output Port Register. However, if the Configuration register bit is set to 1 (Input), all changes made to the
output register will not be applied as only the read protocols are allowed from the input port register.
WARNING: The Option card portion of the iSM website MUST be manually kept in sync with the
value of the Configuration Register. Failure to do so will result in unexpected results.
Configure the Card Using iSM
The iSM provides a facility for changing the modes of the card. Each port has two options that can be set,
the mode and threshold. The mode can be configured as input or output and the threshold can be set to a
voltage level when the mode is set to input.
Keeping the system in sync
The HPE EL300 DIO daughter card is designed to not allow power from a connected device to harm the
internal electronics of the system. To accomplish this, there are two different chips that must be kept in
sync in order for the system to work. While the main chip will always be interacted programmatically, the
second can be accessed manually (using iSM) or programmatically.
Manual syncing
The manual portion includes viewing/setting the second chip using the iSM web interface and then
ensuring whether the main chip has the same settings. To do this, perform the following steps:
1. Open the web browser and browse to the iSM web interface.
2. In the left pane, click Option Card.
The modes of each port determine the bits of the configuration register detailed above.
3. Note the values of each port, Input = 1, output = 0.
4. Make a byte out of these values using port 1 as the LSB (least significant bit) and port 8 as the MSB
(most significant bit).
For example:
20 8 Bit Configurable GPIO Daughter Card (with 12 pin Phoenix Connector)