MAXREFDES150

Introduction

Analog Device's new Pocket IO™ development platform is a reference design integrating a total of 30 IO's consisting of four analog inputs, one analog output, eight digital inputs, eight digital outputs, two RS485 (Profibus-capable field busses), three encoder motor-control ports, and four IO-Link^® masters. Analog Device’s Pocket IO technology demonstration platform shows how analog integration can enable lower heat dissipation and faster throughput in a footprint that is less than ten cubic inches. Pocket IO connectivity is through USB or its own Wi-Fi^® network. Code can be developed to run on the Intel® Edison using the popular and easy to use open-source Arduino^®software IDE.

Detailed Description of Hardware

Pocket IO is the brand name for MAXREFDES150#. The MAXREFDES150# consists of three different boards. The overall system block diagram is shown in Figure 1.

The ICs for the main functional blocks are within the Pocket IO case (the two boards are MAXREFDES150MAIN# and MAXREFDES150LED#) while the connectors are on a separate board (called MAXREFDES150ATACH#) which connects to Pocket IO using two 40-pin cable assemblies.

The control program for Pocket IO runs on the Intel Edison board, which is mounted on the MAXREFDES150MAIN# board. Separate STM microcontrollers are used to support the IO-Link masters (TEConcepts stack) and the DC-motor drivers.

Power Supplies

A single 24V, 1A supply is used to power the Pocket IO and internal DC-DC, and LDO circuits are used to generate the various different voltage levels required by the analog and digital devices. Note: The maximum load this adapter can supply is 1A, which limits how many of the digital outputs are switching loads simultaneously since each of the eight outputs can handle loads of up to 640mA each. The user can use a different 24V supply with 5A (max) capacity. The 24V, 1A supply connects to the block barrel connector, shown on the left in Figure 2.

Pocket IO has three DC-motor controllers, each of which can support +9V to +32V full-bridge DC-motor drivers at up to 2.5A peak motor current. In order to support these higher voltages and currents, a separate user-supplied power supply is required, and connects to Pocket IO through the green three-way terminal. Terminal 1 is used (with Terminal 3) to test the polarity of the external supply (to protect Pocket IO motor drivers from reverse polarity connections). In normal-use mode Terminal 2 is the +9V to +32V connection and Terminal 3 is the ground or 0V connection.

Connections

The main functional blocks are on the two PCBs within the Pocket IO case while the connectors are on a separate board, called MAXREFDES150ATACH# shown in Figure 3.

LED Indicators

Figure 4 explains the functions of the LED indicators for MAXREFDES150#.

Hardware Sections

Analog IO

ADC Analog Inputs (pages 2-6 of MAXREFDES150MAIN# schematics)
The heart of the analog front end (AFE) is the MAX11254, a 6-channel, 24-bit delta-sigma ADC that achieves exceptional performance while consuming very low power. The MAX11254 communicates through an SPI serial interface to the Edison processor. Four channels are used; channels 0 and 1 are configured for voltage inputs and channels 2 and 3 for current inputs.

Voltage Reference

MAX6126 precision voltage reference is used to generate a 3.0V reference signal (VREFAO for DAC), which feeds a resistor divider to create 1.5V input to a MAX44244 precision low power op amp configured as a unity-gain buffer, providing a 1.5V reference signal (VREFAI for ADC).

Voltage Inputs

Two op amps are used to provide signal conditioning for each of the inputs to ADC channels 0 and 1. Each channel has a ‘positive’ and ‘negative’ input pair to provide a differential input range of 12V, 0V to +12V range per pin. The first amp uses MAX44267, which is a Beyond-the-Rails™ amplifier capable of providing a bipolar output from a single positive +15V supply. The second stage uses a MAX44248 configured as an inverting attenuator centered around 1.5V input level, providing an input to the ADC channel of ±1.38V differential. The input range for analog inputs 0 and 1 is 0V to +12V range per pin and it is recommended to use the voltage calibration sketch, which performs a 2-point calibration and stores gain and calibration values in the MAX11254 to provide over 0V to +10V range commonly found in industrial applications.

Note: The inputs can accept signals to +13V before the ADC input range of ±1.5V is exceeded, providing extra headroom beyond the recommended operating range.

Current Inputs

Two op amps, two FETs and a TVS are used to provide signal conditioning for the inputs to ADC channels 2 and 3. Overcurrent protection is provided by the two FETs, which ‘opens’ if the input current exceeds 50mA to 70mA. In addition, the TVS triggers if the input voltage is > 24V and the series resistor limits current to the op amp to avoid damaging the op amps. The input current (±24mA) is converted to a voltage by a 15.4Ω resistor producing ±370mV, which is buffered by a MAX44267 amplifier, and then attenuated by a MAX44248 amplifier with a gain of 0.95V to produce a differential input voltage to the ADC, channels 2 and 3, of ±352mV.

Power Supplies

The analog I/O section has isolated data and power that provide low noise 15V (AV15V) and 3.6V (AV3V6) rails with respect to analog ground (AGND). Refer to the section on the power tree for details about how these rails are generated.

DAC Analog Outputs (page 8 of MAXREFDES150MAIN# schematics)
MAX5216 is a 16-bit, low-power, buffered output, rail-to-rail DAC with an SPI Interface for interfacing to the Intel Edison. The 3.0V reference signal (VREFAO) generated from MAX6126 is used to set the full-scale range of the MAX5216. A precision, low-noise, wide-band amplifier, MAX9632 is used to provide a gain of 4, giving an output range for AO of 0V to +12V. To ensure the output can truly go to zero volts the negative supply of the MAX9632 is powered from a -3V supply (AVM3V).

Digital Isolation (page 9 of MAXREFDES150MAIN# schematics)
Two different digital isolators are used to provide data signal isolation for the analog I/O section. MAX14130 is a four-channel digital isolator used to isolate the SPI signals for CLK, MOSI and the two-chip select signals for the ADC and DAC. The MAX14130 also provides voltage translation between the 1.8V signals from the Edison and the 3.6V signals from the ADC and DAC. MAX14850 is a six-channel digital isolator with four unidirectional channels (2-2) and two bidirectional channels. The unidirectional channels are used to transfer CLR and RESET signals to the data converters and to return the RDY and SPI_MISO signals to the Edison.

Digital IO

Digital Inputs (page 12 of MAXREFDES150MAIN# schematics)

MAX31913 is an industrial, octal, digital-input translator-serializer. On-chip serialization takes the eight input channels, and outputs data through the SPI interface to the Intel Edison. The device features input-current limiting, allowing a significant reduction in consumed power, which is set by a single 15kΩ resistor (R806) connected to the RIREF pin, setting the current limit at 2.4mA. A series 2.2kΩ resistor on each input ensures the device is compatible with IEC 61131-2 Input Types 1, 2, and 3. The MAX31913 is powered from a single +5V supply removing the need for a 24V supply to this IC. Two software addressable bits, DI_DB0 and DI_DB1 control selectable on-chip low-pass filters allowing flexible debouncing and filtering of sensor outputs based on the application. 8 LEDs are used to show the status of each digital input channel.

Digital Outputs (page 13 of MAXREFDES150MAIN# schematics)

MAX14913 is a digital-output-octal high-speed, high-side switch/push-pull 24V driver capable of 200kHz switching rate, The MAX14913 has eight 640mA smart high-side switches that can also be configured as push-pull drivers for high-speed switching. The device is configured and controlled through the SPI interface. The 4 x 4 LED driver crossbar matrix is used for driving 16 LEDs to indicate per-channel output status and the fault conditions. Care needs to be taken when selecting the output loads to ensure they do not exceed the 1A capability of the power adapter supplied. For higher currents, a different supply is required.

Motor Control

DC Motor Driver (page 20 of MAXREFDES150MAIN# schematics)

MAX14870 motor drivers provide a small, low-power and simple solution for driving and controlling brushed DC motors and relays with voltages between 9V and 32V. Very low driver on-resistance reduces power dissipation. Input power for theses circuits is supplied by the green connector, which supports up to 2.5A motor current.

Motor Encoder (pages 14 and 15 of MAXREFDES150MAIN# schematics)

MAX14890 incremental encoder receiver contains four differential receivers and two single-ended receivers. The differential receivers can be operated in RS-422 or differential high-threshold logic (HTL) modes and are optionally configurable for single-ended TTL/HTL operation.

IO-Link (pages 3 to 5 of MAXREFDES150LED# schematics)

The MAX14824 is an IO-Link master interface that integrates an IO-Link physical layer transceiver with an auxiliary digital input and two linear regulators. High port count IO-Link master applications are supported through in-band SPI addressing, and the SPI interface minimizes host controller access times. In-band addressing and selectable SPI addresses enable cascading up to 16 devices although in this design only four devices are implemented. The device is IO-Link v.1.0 and v.1.1 physical layer compliant and supports all the IO-Link data rates (COM1, COM2, and COM3). The driver is guaranteed to drive up to 300mA (min) load currents and features slew-rate-controlled drivers to reduce EMI.

The 4-port IO-Link master uses TEConcept’s IO-Link master stack, with the software running on a STM32F103 ARM^® Cortex^® M3 microcontroller (U1101). The four MAX14824’s (U1201/U1301/U1401/U1501) each connect to a UART in the STMF103 as well as through a local SPI bus for configuration. MAXREFDES150# ships with the master stack preprogrammed inside the MAXREFDES150# hardware with an indefinite time license. For further information about TEConcept and their software, contact TEConcept GmbH:

TEConcept GmbH
Wentzingerstr. 21
D-79106 Freiburg
Tel. +49 761 21443640
Fax +49 761 21443631
Email: info@teconcept.de
www.teconcept.de/Contact.php

Communication Ports (page 10 of MAXREFDES150MAIN# schematics) RS-485 Interface

Two RS-485 interfaces (COM0 and COM1) are provided using the MAX14783E, a half-duplex RS-485/422 transceiver that operates at either 3.3V or 5V rails with high ±35kV ESD performance and up to 42Mbps data rate. For MAXREFDES150# the two devices (U1001 and U1003) operate from a 3.3V supply and connect their driver and receiver connections to individual ports of the MAX3109 dual UART. The RS-485 ‘cable’ pins (A and B) are connected directly to the RS-485 connector on MAXREFDES150ATACH# card.

UART

The two RS-485 transceivers connect to a MAX3109 advanced dual universal asynchronous receiver-transmitter (UART), which has 128 words of receive and transmit first-in/first-out (FIFO) and connects using a high-speed SPI interface to the Intel Edison.

Power Supplies

The power tree for MAXREFDES150# is shown in Figure 5.

The two power inputs are the 24V MAIN using the barrel connector and the VMTR using the green connector. When used with the supplied 24V adapter, the maximum current available is 1A, which limits the user in terms of the digital-output loads, which can be switched. The ‘digital supplies’ and the ‘analog IO supplies’ are protected from reverse polarity and overcurrent using a 1A fuse (F3). The MAX17502 high-efficiency, high-voltage, synchronous step-down DC-DC converter with integrated MOSFETs operates over a 4.5V to 60V input voltage range. This device is offered in a fixed 3.3V, 5V, or adjustable output voltage (0.9V to 92%VIN) while delivering up to 1A of current. The output voltage is accurate to within ±1.7% over -40°C to +125°C. Two MAX17502s are used to generate the 5V (V5V) and 3.3V (V3V3) rails. Intel Edison requires a 4.3V supply, with a MAX17620, high-frequency, high-efficiency synchronous step-down DC-DC converter used to generate VSYS from the 5V input. MAX17620 operates over a 2.7V to 5.5V input-voltage range and supports V_OUT up to 100%. High-frequency operation enables the use of small, low-cost inductors and capacitors making it ideal for small form-factor solutions such as Pocket IO.

If the user wishes to run higher current loads for the digital outputs, a higher capacity supply (V24V) needs to be connected to the barrel connector. The circuit is designed to support up to 5A loads and is protected from over current by F1 a 6.3A fuse. The 24V supply (V24) is brought out to MAXREFDES150ATACH# to provide the user a flexible 24V source. These pins are protected from accidental short circuits using MAX17523* overcurrent protection device.

The Analog IO section is powered using an isolated supply, created from VPWR (24V) using MAX17681, a high-voltage, high-efficiency, iso-buck DC-DC converter designed to provide isolated power up to 3W. The device operates over a wide 4.5V to 42V input and uses primary-side feedback to regulate the output voltage. Further rails are generated for +15V (input op amps), +3.6V (ADC and DAC) and -3V (op amp following the DAC).

The three motor controllers receive their power from the green connector VMTR. The circuit is designed to support up to 7.5A loads and is protected from over current by F2, a 10A fuse. The motor supply (VMTR) is brought out to MAXREFDES150ATACH# to provide the user a flexible voltage source. These pins are protected from accidental short circuits using MAX17523* overcurrent protection device.

The three fuses, F1, F2, and F3 are located on the underside of MAXREFDES150MAIN# PCB as shown in Figure 6. These fuses are soldered onto the PCB and replacement requires the user to disassemble the Pocket IO case and to separate the two boards MAXREFDES150MAIN# and MAXREFDES150LED#.

Operating Temperature Range

Analog Device’s Industrial ICs are specified to operate from -40°C to 125°C. However, the Intel Edison is limited to an operating temperature range of 0°C to 40°C. The user should take care not to exceed this temperature range for Pocket IO operation.

Detailed Description of Software

When building up a quick application, or when prototyping some feature, the quickest and easiest way to program Pocket IO, is through the Arduino application. Though not a full-code development, debugging environment, the Arduino sketch technique has a lot to offer, including:

• A familiar interface, instantly recognizable by many
• A full C/C++ compiler
• Access to many useful features built into the Linux OS resident in the Intel Edison processor
• Access to Pocket IO features through an included library
• Access to library updates as they become available

With so much capability packed into one small enclosure, the interface to manage all this is crucial. Each of Pocket IO's 10 resources has its own API. Figure 7 shows the software architecture for Pocket IO using Arduino IDE to compile code to run on the onboard Intel Edison CPU.

The following sections are details about API and some techniques, many Linux-specific, that enhance the capability of your applications.

Detailed Pocket IO API

These sections, organized alphabetically by Pocket IO feature, details the API available to control Pocket IO through sketch.

Note: For information about how to access software revision codes from Pocket IO, consult Boardinfo.ino in the Pio section of the Examples in sketch.

Analog Input

Pocket IO features two analog voltage inputs and two analog current inputs, all easily accessible through sketch. The voltage channels read anything between -12V and +12V whereas the current channels read anything between -24mA and +24mA. Pocket IO features a MAX11254 24-bit ADC featuring built-in two-point calibration compensation, which the API accommodates.

The API selects from among four channels, as follows:

Calibration

The following code snippet shows how to perform a two-point calibration. Commonly, the user locks in the calibration, so it does not need to be done again, and calibration rarely needs to be done. Calibration comes in handy when attaching further circuitry to the analog inputs, and accuracy is to be maintained ahead of this extra circuitry. Pocket IO comes factory-calibrated for best accuracy at the connection points of the attach board.

The code snippet uses port AI0 as an example, but the code is the same regardless of which port is being calibrated. Each channel keeps its own unique calibration parameters.

Reading an Analog Sample

Samples can be read either as a float or as a raw binary code from the ADC. The following code snippet shows how it is done. Because the sample rate is determined by the ADC itself, the user must select from one of the MAX11254 sample times as shown in the following table. Longer sample times result in readings with lower noise. This affects multiple sample reads. For example, with AI_RATE_1_9_SPS, after a first read, the thread calling a read method a second time is blocked for about 526msec.

Analog Output

Pocket IO provides one analog output, capable of any output voltage between 0V and 12V. Since there is only one analog output channel, there is no need to select channels. The API consists of only one method call, and no init() is needed for analog out.

The call to the method is a raw 16-bit code to the DAC. To drive a specific voltage, it must first be converted to a 16-bit equivalent for the DAC, as shown in the code snippet below.

Communications (RS-485)

Pocket IO provides serial communication through two RS-485 ports. Each port is half-duplex, and is preset for 115.2KBAUD at 8N2 (eight data bits, no parity, two stop bits).

Select from among the 2 channels as follows:

The API permits independent reading and writing for each channel. For any given channel, writes supersede reads. No harm occurs if multiple RS-485 transceivers drive a bus at the same time though this means any received data would be corrupted. Use protocol to ensure only one transceiver drives the bus at a time.

Reading data from an RS-485 port is similar to writing, with the added complication that you do not necessarily know how many bytes have been received. The following code snippet shows how to read data.

Digital Input

Pocket IO has eight individual IEC-compliant industrial digital inputs. These inputs connect to binary sensors, such as limit switches, proximity sensors, distance sensors, and user switches. These inputs can be read individually, or as a group, through sketch.

Eight LEDs on the display panel indicate the state of each of these digital inputs. The LEDs are extinguished if driven low or left open, and illuminate when the corresponding input is driven logic high. The following table connects the individual inputs to the values returned through the API

Additionally, the user has access to the debounce feature of the MAX31913 industrial digital input device. This feature reduces chattering of particularly noisy digital inputs. This debounce is global, applying to all digital inputs simultaneously used by Pocket IO. The following code snippet shows how to access these inputs as well as how to manage debounce.

Digital Output

Pocket IO supports eight industrial digital outputs, each capable of driving 24V at greater than 640mA. The API supports many of the features of the MAX14913 or MAX14912 digital output driver IC, including output modes and fault detection.

Each digital output channel can be in one of two modes. High-side mode, as its name implies, only drives a channel high (nominal 24V). Many existing actuators and indicators work best in high-side mode. To have faster output driver switching, each output channel can also be configured to push-pull mode. Since both a high and a low are actively driven, there is no longer a natural decay of the wiring slowing down the transitions from high to low. The following table shows how to specify these through the API.

Each individual digital output can be driven high or low. The Pocket IO front panel allows easy confirmation of the output state, illuminating a green LED for each output being driven high. A matching red LED indicates that a fault has occurred on that output. This most commonly happens when accidentally tying two digital outputs together when they drive conflicting logic levels.

The following code snippets show how to command the digital outputs and manage the mode settings of Pocket IO.

The Pocket IO display panel indicates fault conditions on digital outputs by illuminating a red LED. This fault condition can also be detected through the API. There is a lot more to faults than can be described here, so for more details about fault conditions, refer to the MAX14912/MAX14913 data sheet.

Edison LED

Some Pocket IO resources are not directly related to industrial inputs and outputs. One of these resources is the two LED at the left of the display panel, labelled “EDISON STATUS.” One red and one green LED are purely under the user’s control. The LEDs can be used to indicate progress, status, or activity.

The following code snippet shows how to access the LEDs.

Encoders

Pocket IO has the capability to manage up to three motion-control channels. For many motion-control applications, controlling a motor is enough. For more precise scenarios, feedback is obtained, often from incremental encoders. This section discusses the three incremental encoder interfaces built into Pocket IO.

Incremental encoders communicate position information through two (most common), three (somewhat common) or four (less common) signals. Two-signal encoders are called A and B. Each edge communicates some fraction of a revolution. For example, when using a 4,000 pulses-per-revolution encoder, if you count only the rising edges of the A signal, you can see 1,000 such edges per revolution of the encoder shaft. If you count all edges of both the A and B signals, you can see 4,000 such edges per revolution of the encoder shaft. The timing of the A and the B signals is such that the direction can also be unambiguously determined. The Pocket IO incremental encoder interface uses the A and the B signals to maintain a position count based on the rising edges of the A signal.

A third signal, if it exists, is labelled the Z signal. Sometimes called an index pulse, this optional signal indicates the zero-degree point of the encoder shaft. Pocket IO currently ignores the Z signal. If a fourth signal exists, it is usually labelled the Y signal, and is used to indicate a fault condition in the encoder. Pocket IO has no means to connect to a Y signal.

Incremental encoders have been around for many decades now. Because of this, these encoders are available in a variety of signaling formats, and the MAX14890E encoder used in pocket IO is designed to handle this multiplicity.

Each signal has a “+” connection point and a “-” connection point. For example, the first encoder A signal connects through signals A1+ and A1-. How these are connected to depends on whether the signal format is single-ended or differential. For example, to connect a TTL A encoder signal to Pocket IO encoder channel 1, tie the signal to A1+, and tie the return to A1-. For differential signaling, tie the encoder A+ signal to A1+ and the encode A- signal to A1-. Because of the large common mode tolerance range of the MAX14890E used in Pocket IO, differential encoders usually function well even with no grounds tied between the encoder and Pocket IO.

Several front-panel LED indicators speak to the encoder interface. The yellow LED in the ENCODER section indicates encoder activity whereas the corresponding red LED indicates that an encoder channel has experienced a fault situation. Additionally, the yellow LED in the HS TERM section illuminates when Pocket IO attaches the high-speed RS-422 termination to the corresponding encoder channel.

Each Pocket IO encoder channel has its own signal format selection, communicated to the API by consulting the following table.

Select from among the 3 encoder channels as follows:

This code snippet shows how to set encoder signal formats, and how to obtain encoder information.

IO Link

Pocket IO supports a 4 channel IO-Link master. This allows for control of up to four separate IO-Link devices, These devices can be sensors, actuators, communication hubs, etc. This enables the Pocket IO to expand on its already impressive offering of IOs. For instance, if all four IO-Link channels were connected to a x16 DI expander, this would increase the DIs of the Pocket IO to 64 + 8 = 72 total digital inputs.

The Pocket IO has four yellow LEDs for each IO-Link channel, labeled 1-4. If the specific IO-Link channel is initiated for communication, then the yellow LED is dimly lit. Note, these LEDs can be lit even if the protocol stack hasn’t been initiated for that channel, the device may be configured to enable in certain conditions in binary mode, hence lighting the LED. This is usually a brighter yellow than the yellow from the IO-Link communication. There are also two other LEDs with the label PROTOCOL underneath. If the red LED goes high, then this means the stack has had a hard fault and needs to be power cycled. This should not happen, but if it does power cycling is the only remedy.

The IO Attach Board has four M12 cable receptacles for attaching cables between the Pocket IO master and devices. These receptacles are slightly raised off the board, which may look like an error in assembly, but this is normal. The cables are to be inserted and screwed for a secure connection. This can be tricky so be sure to have the connector fully inserted. Also, make sure to have the device connected on the other end of the cable, and to have recorded which devices are on which channels. This is important for correct operation of the IO-Link stack.

Assuming the physical connections and power are set, one must also install the appropriate IODD files onto the Pocket IO. This needs to be done for each unique IO-Link device, and only needs to be done once, unless new devices are added, in which case the new respective IODD files would need to be installed too. You will need to get these device IODD files from the device manufacturer, they should be in XML format. Once the files are obtained, connect a USB cable from the PC to the micro-USB port closest to the green power terminal. It may take a while as the PC discovers and installs the appropriate drivers, but the Pocket IO should eventually appear as a removable storage drive. It is most likely to appear as EDISON. Once available, drag and drop all desired IODD files onto the EDISON drive. Remember how you named these files and if they were in any subfolders, the complete file path is needed for use.

The Pocket IO IO-Link library can be broken up into 2 major parts, the setup and the application. The setup is always required and follows the same pattern. Please see the example code snippet below for the setup.

The other major part would be the application. This could be requesting process data from the IO-Link device or writing to the ISDUs of the device. This can be done once or multiple times, and can determine the action of other IOs. The extent of use depends on the specific application but the code snippets below show how to use the basics; how to use the information is left to the user.

Below is a code snippet for collecting process data. It is assumed that you would have already called the setup snippet shown previously.

The other application example would be reading and/or writing to the ISDUs of the IO-Link device. It is not required to do both, either or is ok. Below is a code snippet for this case, it is assumed that you would have already called the setup snippet shown previously.

For more detailed and accurate examples, please view the examples provided with the library.

Motor Control

A nice feature of Pocket IO is the ability to control up to three brushed DC motors. A separate green-colored connector supplies the motors, permitting the use of motors from 4.5V to 32V. During startup and other high-speed changes, each motor is limited to about two amperes of drive current. Because the motor driver is a full-bridge MAX14870 device, there is no ground connection to the motor, only to its two terminals.

The Pocket IO indicator panel shows the motor driving state for each motor port. A green LED illuminates when driving a motor clockwise, and a yellow LED illuminates when driving a motor counterclockwise. The higher the speed, the brighter the LED.

To adjust motor speed, Pocket IO provides an 8-bit PWM control for each motor independently. Select from among the 3 motor channels referring to the following table:

The API maintains a concept of rotation direction. When driving clockwise, the “+” connection averages a higher voltage than the “-“ connection. When driving counterclockwise, the “+” connection averages a lower voltage than the “-“ connection. The following table shows how to describe this.

'Stopping' a motor can mean two different things. In one case, it can mean actively braking the motor with significant resistance to motion. In the other case, it can mean coasting, where there is little resistance to motion.

In the case of a DC-brushed motor, the difference can be significant. If the motor is part of some internal mechanism where there is no expected movement, then braking is the correct approach. With braking, forcing movement of the motor can prematurely wear out the motor brushes. However, if there can be movement of the motor after stopping, coasting is probably the better approach. The disadvantage of coasting is that the motor does not stop suddenly, so it can excurse past where you want to stop.

In some situations, you would like to stop motion solidly, but still permit a user to move a mechanism by hand. A good compromise in this situation is to brake the motor for a short time, and then coast the motor.

The following table summarizes the possible states of motion for the motors.

The following code snippet shows how to manage the motors through Pocket IO.

User LED

Some Pocket IO resources are not directly related to industrial inputs and outputs. One of these resources is the eight-user LED toward the bottom of the display panel, labelled “USER.” You have two blue, red, yellow, and green LEDs, that can be used to indicate anything (under the user’s control).

The following table correlates USER LED with code.

Generally Useful Techniques

This section is a collection of tips and techniques that could be useful when writing more realistic programs. Some of these rely on Edison running Linux, with concomitant support in the sketch tool.

Debug Serial Port

Arduino sketch is great to get something up and running fairly quickly, but it does not support sophisticated debugging techniques such as breakpoints and watches. One possible solution is printing to a debug terminal. It turns out that you can print to the secondary “AUX USB” port in your programs, the same port that gives you shell access. The trick is to use “Serial2.xxx()”.

Using this method, you need to open and close the port once. After that, you can use the same methods useful in other sketches, such as “println()”, “print()”, “read()” and “available()”. Refer to the code sample below.

Digital Input Trick

Many makers learn early that putting an LED across a power supply without a current limiting resistor is bad for the health of the LED. However, industrial digital inputs naturally current limit to a few milliamps, so if you are prototyping, and want to make sure your DI is getting something like 24V, use an LED in series with the DI input. The current limit is about right to make most LEDs glow nicely.

Standardized Initialization Routine

For a routine to put MAXREFDES150# into a known and innocuous state, use the following code snippet. Call initPocketIO().

Converting a Voltage Accurately Without Using Floating Point

For those who wish to get every ounce of performance they can, floating point math is to be avoided wherever possible. The MAXREFDES150# standard routines provide a readFloat method for analog input, but this uses a floating point to provide a value in volts. For voltage readings, we take advantage of the calibration registers built into the MAX11254ATJ. For this reason, after calibration, +12V always corresponds to a full-scale value from the readCode method, or 0x7fffff. With this knowledge, and a bit of integer math, we can convert the value from the readCode method to an accurate integer, representing the value in millivolts. Here is the technique:

Doing Several Things At Once

When writing code more realistic than the examples given, it is often necessary to have multiple things happening at once. One traditional way to accomplish this, is to have a polling loop, continuously scanning for trigger conditions, and calling dispatch methods when appropriate. Though fast and effective, his method splits related code in multiple places, encourages convoluted coding, and soon becomes challenging to debug and maintain.

Fortunately, Linux supports threading, a feature that can be accessed from the sketch programs. Specifically, the OS build in Edison supports posix threads. With threads, you can have multiple snippets of code seemingly running at the same time. As if multiple sketches were running at the same time, only better.

The following code example runs a walking pattern on the USER LED and blinks the encoder LED simultaneously using threads. You need to copy some code above into a file name “pio-startup.hpp”, placed in the same folder as “SimpleThreading.ino.” The encoder code works because changing to RS422 mode engages the high-speed termination, and also indicates a fault failing from too low a voltage difference on the signals from the nonexistent encoders.

Part of the reason the above code is so simple is that it never terminates. If you want to exit cleanly, there is a bit more work to do. It is common for each thread to clean itself up before exiting. For those threads that run continuously, you often see a global termination flag with each continuously running thread inspecting this flag regularly.

The issue is that you have no way to control which thread terminates before or after which other thread. This is where those thread handles come in handy. The trick is to make threads joinable, and then, when terminating, have code in the setup() or loop() methods wait for all the other threads to complete. This second step is called thread joining. In this context, joining means waiting for another thread to complete.

This code snippet replaces the two-thread, creates calls in the code above, and makes them joinable:

If you have cleanup code in your threads before they terminate, you need to wait for them to complete. In this example, you would add the following code at the place where you are waiting to end:

Keeping Threads From Interfering With Each Other

For a progress indicator follow this recommendation. After creating a thread that either blinks an LED or not, depending on the state of a flag, you can have other parts of your code turn the indicator on or off, at most any time. It’s possible to create a thread that looks at a flag; if the flag is set, blink an LED, and when the flag is reset, stop the blinking.

A potential problem arises if this flag can be touched in more than one thread. You need to protect two threads from trying to run over each other touching the flag. This common situation is also covered by POSIX, with something known as a mutex (stands for mutual exclusion). For each flag that needs this kind of protection, create a mutex and protect the flag by locking the mutex before you touch the flag; after unlock the mutex. You must do this everywhere your flag is touched because a locked mutex suspends any thread that tries to lock that same mutex until it is unlocked. It is also a good idea to declare the flag volatile. Actually, you have been using mutex all along and did not know. The MAXREFDES150# calls for the writeLed() method, for example, which are wrapped in an internal mutex in case you are calling from multiple threads.

The following code snippets show how this is done:

Keeping Timing More Accurate

The delay() method is very handy. It temporarily puts code to sleep. With threading, it provides more opportunities for other threads to run. The delay method, however, guarantees only a minimum delay. Especially when running multiple threads, a loop based on the delay function can appear jittery or slow.

The problem is the delay begins at the point the delay call is made, so any extra time taken to wake up from the delay method accumulates. We can go some way to alleviate this by causing wakeup at absolute times. This way, any extra time taken to wake up from the delay makes the next wakeup shorter.

The technique makes use of an OS structure called timespec, and a sleep based on absolute time. You start by grabbing the OS time, then you add a fixed increment to that time, and use that with a call to a function that says: “wake me up when your system clock reaches this time.” This is how we would modify the procUserLed thread above to trigger on absolute time:

IO-Link IODD Loading

Typically, when you get an IODD file from the manufacturer it is located in subfolders. The folders usually also include PNG files of graphics and logos. For the Pocket IO, these PNG files aren’t necessary and the subfolder structure may be burdensome. You might have noticed from the API section that if you intend to use a device’s IODD, you need to specify its file path with the method, setChannelWithIoddFilePath. This is usually a good reason to reduce the number of subfolders and the length of the IODD file name. Doing so can prevent simple errors from typos, and improve readability of the code.

It is also part of the API for the method that it returns true or false depending on whether it was able to find the specified file. This can be an insurance against typos, the file being deleted, or the code being loaded onto a new Pocket IO, that doesn’t have the IODD files yet. The code snippet below shows some ways to utilize this.

Trying to Prevent IO-Link Faults and Crashes

If a fault occurs, the red LED above the PROTOCOL label might go on, or the yellow status LED for each of the IO-Link channels might begin to periodically flicker. These should not normally occur, but it is possible to accidently cause this. We will look at how this might happen and provide some solutions to help prevent them.

Firstly, if you have started IO-Link communication with a device and then physically disconnect the device, this causes the IO-Link stack to crash. One should never disconnect a device unless the IO-Link communication is stopped.

Secondly, make sure you have the correct device assigned to the channel. It is common for people to mix up which devices are connected to which channels, especially when all four channels are used and they are all different devices. Thus, if you call set Channel With Iodd File Path with the wrong IODD for that channel, it will return a success, because it found the appropriate IODD file at the path provided, but it does not behave as expected. The mismatch of devices determines the type of failure; it is unknown, but it is incorrect. Hence, it might cause a fault with the IO-Link stack. Therefore, try to double check that you have the correct IODD files assigned to the correct channels.

Thirdly and probably least obvious, is the condition where you have an IO-Link program loaded and it talks to channel 1 repeatedly. Say you power down the Pocket IO, and then remove the IO-Link device from channel 1. It would seem to be ok; however, if you then power on the Pocket IO, the program starts up again automatically and setChannelWithIoddFilePath returns true, as it would be able to find the IODD file and assign it, but then the stack crashes once it tries to communicate with the device that is no longer connected.

There are some circumstances where this might be ok. Say you upload new code to the Pocket IO and then power cycle again; this is ok. However, it is common to load new code and try it out before power cycling, and it might be unclear why the IO-Link stack is unresponsive. The Pocket IO does not recover until power has been cycled.

There are a couple of ways to prevent this from happening. The most secure way, but not always practical, would be to call the method, stopIoLink(uint8_t channel), for every channel you started. You would call this method once you were done with the IO-Link communication or the program was terminating.

There are many cases where the program runs indefinitely; hence it only terminates once power is disconnected. In these situations, if you are going to remove devices and change the configuration, it is recommended to upload an example that doesn’t use the IO-Link stack, like the "PioEdLedBlink" example. Once it starts to run and you toggle the switch to make sure the program is saved to nonvolatile memory, it should be ok to turn off power and disconnect IO-Link devices. Thus, now on power-up it does not try to communicate with an IO-Link device that isn’t there, but merely toggles the LEDs; hence preventing the IO-Link from crashing.

Quick Start

Required equipment

• MAXREFDES150# Case (Pocket IO) with MAXREFDES150ATACH#
• Two 40-pin cable assemblies
• 24V, 1A power supply
• USB cable
• Windows^® PC with a USB Port
• Arduino IDE Software

The first step is to connect the Pocket IO and the connector board, and then to install and configure the Arduino-based software tools.

Power Supplies

A single 24V, 1A supply is used to power the Pocket IO and internal DC-DC, and LDO circuits are used to generate the various different voltage levels required by the analog and digital devices.

Note: The maximum load this adapter can supply is 1A, which limits how many of the digital outputs are switching loads simultaneously since each of the eight outputs can handle loads of up to 640mA each. The user can use a different 24V supply with 5A (max) capacity. The 24V, 1A supply connects to the block barrel connector, shown on the left in Figure 2.

Connections

The main functional blocks are on the two PCBs within the Pocket IO case while the connectors are on a separate board, called MAXREFDES150ATACH# shown in Figure 3, which connects to Pocket IO using two 40-pin cable assemblies as shown in Figures 8, 9 and 10.

For testing MAXREFDES150# connect the Pocket IO boards in the plastic case to the MAXREFDES150ATACH# board using the two cable assemblies. Note each cable is the same, but one connector has a plastic 'key' to mate correctly to the male connectors on the MAXREFDES150ATACH# board. Start by connecting to the MAXREFDES150ATACH# board making sure the red line on the cable matches the Pin 1 triangle on J1 and J9 for the MAXREFDES150ATACH# board (Figure 8).

Then connect the two cables to the male connectors at the rear of the Pocket IO plastic case; note how the red line on the cable is on the left hand side (Figure 7).

Make sure you do not cross the two cables (Figure 10).

Finally, take the 24V wall adapter and select the correct fixture for the local power outlet; the kit is supplied with adapters for England, Europe, USA and Australia standards (Figure 11).

Connect the 24V supply to the barrel connector on the plastic case (Figure 12).

Pocket IO is now ready to be powered on and tested. Testing requires a PC loaded with Arduino software for Pocket IO.

Procedure

Analog Devices Pocket IO Arduino Installation Instructions

1. Download and install the latest Arduino IDE.
   
   

   a. Go to https://www.arduino.cc/en/Main/Software.

   b. Select the appropriate OS link (Windows, MAC^®, Linux^®). For this Quick Start we assume the OS is Windows PC.

   

   c. Follow the prompts to download and save the file.

   

2. Install the latest Arduino IDE.
   
   

   a. Once the download has completed double click 'Arduino-x.x.xx-windows.exe.'

   b. Windows then prompts you to run this file, select 'Run.'

   c. The Arduino setup displays the license agreement, select 'I Agree.'

   

   d. It prompts you to select components to install, select 'Next.'

   

   e. Next it shows the destination folder to install, select 'Install.'

   

   f. When Arduino setup is completed select 'Close.'

   

3. Install Analog Device's Pocket IO Board.
   
   

   a. Locate the 'Arduino' shortcut on your desktop and double click the icon to open the Arduino IDE.

   b. A window opens as shown below, select File > Preferences.

   

   c. In the 'Preferences' window there is a section 'Additional Boards Manager URLs.' Select this box.

   

   d. In the box that opens, copy and paste the URL below into this window and select 'OK', then 'OK' again. https://raw.githubusercontent.com/maximTicer/pocketio/master/package_maxim_index.json

   

   e. Select Tools > Board > Board Manager.

   

   f. Open the 'Boards Manager' window and from the drop down Type menu select 'Certified.'

   

   g. Select 'Intel i686 Boards by Intel' for Edison and click 'Install' to install rev 1.6.7+1.0 or later.

   

   h. Once installation is completed, select 'Close.'

   

   i. Open the 'Boards Manager' window and from the drop down Type menu select 'Contributed.'

   

   j. Select 'Maxim Boards by Maxim Integrated' for Pocket IO, select the latest revision and click and click 'Install.'

   

   k. Once installation is completed, select 'Close.'

   

   Note: If the user is updating from a previous release to a newer release of the Pocket IO Board Manager, it is necessary to follow all of these steps:

   1. Do NOT use the"Update" button.

   2. Click "Remove" button to uninstall the existing Pocket IO libraries.

   3. Fully close, then re-open all the Arduino IDE windows.

   4. Select the version from the drop down menu and click to "install" the updated version of Pocket IO libraries.

4. Using the Pocket IO with Arduino IDE.
   
   

   a. To select Pocket IO as the target board, select Tools > Board > Analog Devices Pocket IO.

   

   b. Make sure Pocket IO is powered with 24V, and connect the USB cable to the micro-USB connector labeled 'Edison Status' (the one nearest to the green connector).

   c. Select Tools > Port > COMXXX (where xxx is whichever COM port was selected when you plugged it in).

   

   d. Next select File > Examples > PioDo > PioDoBlink.

   

   e. A new window should appear with the example sketch selected. Press the circular button with the check mark in the top left corner to 'Verify' or compile the sketch.

   

   f. The window indicates it is compiling with a progress bar, and when finished, displays 'Done Compiling.'

   

   g. Now select the circular button with the right arrow, 'Upload' transfers the data to the Edison and starts to run the compiled program.

   

   h. After a few seconds the message 'Done Uploading' is displayed and you can see the LEDs on the board flashing driven by the digital outputs.

   i. A number of standard functions are included as examples to showcase the functionality of Pocket IO, or the user can develop their own sketches.

   j. Analog Devices has loaded a Pocket IO image to the FLASH memory on the Edison module to replace the standard Edison image. Whenever the Pocket IO reboots, such as after power cycling, the last Arduino sketch is loaded by default. This is not the case for the standard Edison image. Pocket IO comes preconfigured with a sketch to blink the user LEDs.

Examples Showing Pocket IO in Typical Industrial Control Applications

Use Case – Digital Inputs and Digital Outputs

Here we discuss a possible subset of a real industrial control application. This setup consists of a light tower, with green, orange and red, representing normal, warning, and alarm statuses, respectively. The light tower is set by the digital outputs from the Pocket IO. There are also 2 inputs; one is an optical proximity sensor. This proximity sensor warns the user (orange light) if some equipment has come out of alignment and perhaps needs to be serviced. The sensor has been set to trigger at the appropriate distance away. The second input is a physical limit switch; if this is contacted it means a piece of equipment is about to collide and cause critical damage to the factory and hence an alarm (red light) should be set and the equipment halted. These go to the digital inputs of the Pocket IO. If neither input is tripped, then it is assumed that the factory is in a normal operating state (green light). Below is a table with the IOs for the application.

Below is a code snippet of what this might look like.

Arduino is a registered trademark of Arduino, LLC.
ARM is a registered trademark and registered service mark and Cortex is a registered trademark of ARM Limited.
Beyond-the-Rails is a trademark of Analog Devices Integrated Products, Inc..
IEC is a registered service mark of the International Engineering Consortium, Inc.
Intel is a registered trademark and registered service mark of Intel Corporation.
IO-Link is a registered trademark of Profibus User Organization (PNO).
Linux is a registered trademark of Linus Torvalds.
Mac OS is a registered trademark of Apple Inc.
Pocket IO is a trademark of Analog Devices Integrated Products, Inc.
Wi-Fi is a registered certification mark of Wi-Fi Alliance Corporation.
Windows is a registered trademark and registered service mark of Microsoft Corporation.