IOTester® development kit
The easy way to:
- Connect peripheral I/O hardware to a PC for direct use by a PC program.
- Develop and test driver software for embedded I/O peripherals with common PC tools.
- Accelerate Graphic User Interface (GUI) application development for embedded systems.
- Take advantage of highly efficient and low-cost PC tools during embedded program development.
- Create sales demonstrations for embedded I/O peripheral hardware.
- Get a simple, easy-to-use, interface for production testing of embedded I/O hardware.
|
IOTester-USB Overview
Configurable Target Interface:
- 45 I/O pins, individually programmable
- 8 or 16-bit external processor bus
- Serial SPI bus
- Serial I2C bus
- 18 or 24-bit RGB bus (TFT/OLED displays)
- Interrupt Input pin
Built-in I/O devices in IOTester-USB:
- Interrupt pin event counter.
- Interrupt controller. Route target interrupt events to interrupt functions on the PC.
- 1 ms timestamp counter
- 10 ms interval timer. PC interrupt support
- Display controller with frame buffer RAM
- Fill / Copy accelerator
- Touch screen controller, 4-wire resistive, PC interrupt support
Power supply
- 3.3V logic to target. 5V tolerant inputs
- DC input from 5V adaptor or USB connector.
- Small target systems can be supplied via IOTester. 3V3 or 5V.
|

Multiple IOTester devices on the same PC
- One PC application can operate 4 IOTester devices as one logical device. 180 I/O pins in total.
- Different PC applications using different IOTester devices may run simultaneously on the same PC.
PC driver software
- Win32 support. XP, Vista, Win7.
- High-Speed USB 2.0 support
- Simple DLL interface. C/C++ interface module and examples included.
The interface is easily adaptable to tools for other PC compiler languages: C#, Basic, etc.
|
|
|
|
The IOTester® concept:
Access to your embedded I/O peripheral hardware directly from a PC program
|
|
Virtual "embedded processor bus"
|
The IOTester tool creates an "embedded processor bus" for your I/O peripheral hardware.
Part of the bus address range goes to internal IOTester registers, while
another part goes to the external bus (if the external "processor bus" is enabled).
IOTester® "connects" I/O hardware to the PC system in such a way
that I/O registers can be accessed and controlled directly from a program application
running on the PC. From a programmer's point of view, this is done just as
easily as if the target I/O was a virtual part of the PC.
The IOTester® software interface essentially consists
of initialization functions and a few access functions for the most basic
operations on I/O registers: READ, WRITE, AND, OR, XOR on either individual
registers or register arrays.
Interrupts from IOTester devices are serviced by interrupt service functions in the PC program.
"Target Interrupt" functions can be programmed and tested logically on the PC just like any other program part.
|
|
Early prototyping
|
Connect your target I/O hardware to IOTester pins and control it directly from a PC program.
The simplest, fastest, and easiest way to test and use embedded I/O peripherals in a new target system.
Ideal for initial experiments and device driver development.
For instance: I/O peripherals with a bus interface (e.g. Display controllers, AD converters, touch screen controllers), or simple I/O logic pins (e.g. LEDs, relays, keyboard matrix).
Use your new GUI interface hardware (e.g. display, keys, touch screen) before your target processor system is ready.
The best way to get "look-and-feel" acceptance, and even customer feedback, early in the development cycle.

|
|
Easy to get started
|
IOTester provides a simple, fast and easy-to-use interface, which is optimal for initial experiments
with new I/O hardware. No special Windows programming knowledge required.
It is enough to use a simple Console project, i.e. create a PC program starting from main().
Add the iotester.c module to the PC compilation project.
Initialize the IOTester / target connection with a call to iot_init(0),
and you have instant access to I/O registers and memory in your target hardware.
#include <iotester.h>
int main(void)
{
if (iot_init(0)) // Open access to virtual I/O address space.
return -1; // IOTester was not connected to PC
// IOTester is ready.
// Make your I/O access operations via iowr(..), iord(..) etc
// etc.
return 0;
}
See more examples for how to get started with IOTester
|
|
Create portable I/O driver source code
|
IOTester uses a portable syntax for I/O register access.
The portable (macro) functions for I/O access enable easy mapping to any syntax for I/O
register access used by a specific embedded target C compiler. With many of today's embedded
compilers the IOTester access functions can be used directly without modification.
In this way, IOTester facilitate development of compiler-independent I/O driver source code for
peripheral chips, and promotes the reus of I/O driver source code across projects, compilers,
OS systems and embedded processors.
This inherent portability between a PC compiler and an embedded target compiler can be used with
advantage be used to accelerate the development process for your embedded program application,
because it allows you to use the full PC environment and common, low-cost, PC tools
|
|
Accelerate embedded program development by using of common PC compiler tools.
|
|
Efficient development environment
|
Use common, highly productive, and low-cost PC tools for embedded program
development, for instance, some of the free PC C/C++ compilers on the market.
Take advantage to the best PC program debugging tools to speed your development.
The Integrated-Development-Environment (IDE) of many PC compiler tools provides
an efficient debugging environment with very short debug turn-around times
(debug test->edit->compilation->re-run to breakpoint).
|
|
Easy dynamic runtime debugging
|
The PC screen is directly available from the "embedded" program:
- Easy to insert dynamic run-time messages.
- Use non-break monitoring of the "embedded" system behaviour.
The full PC file system is directly available:
- Easy to log and document dynamic signals from, for instance, transducer sensors, A/D converters, etc.
- Easy to log and document dynamic control signals from the "embedded" application program to the application.
Simple to insert test code in the program:
- Log real-time event sequences or data streams
- Use event or data replay to get stable and repeatable debugging conditions.
|
|
Extended test tools
|
Take advantage of the many (low-cost) PC test tools on the market for embedded
program development to increase the quality of your final embedded program application.
For instance, Test Coverage measurement tools, Execution Profiling tools etc.
|
|
Unconstrained environment
|
On the PC, an "embedded" application can be developed and tested without the program and data size constraints
typical of small embedded processor systems.
You can focus on getting a logically correct source code, before spending
development time on dealing with detected timing or memory size constraints.
When the application is running logically correct, it is easy to measure and find out exactly where it
is relevant and most beneficial to spend development time on optimization efforts.
For instance, using program profiling may indicate the program parts where the "bottle necks" are located.
|
|
IOTester provides flexible connection to external embedded I/O hardware
|
|
Single chip mode
|
45 individual I/O pins can be configured and controlled via internal I/O registers.
Individually programmable as input or output. With or without internal pull-up.
Single-chip mode and external-bus modes can be mixed.
Any pins not used by external bus or other internal devices are I/O pins by default.
|
|
External parallel bus
|
Multiple data and address bus layout modes enable optimum IOTester pin utilization.
8 or 16 bit data bus
Programmable external address bus size from 0 to 24 pins.
Programmable control line modes: 8080 bus (/WR, /RD clocks), 6800 bus (R/W, Eclk). Reset and Chip-Select pins
Programmable bus clock wait-state timing. /WAIT input line for bus clock width control.
|
|
Serial SPI bus
|
One or more SPI bus slave devices can be connected to the external SPI bus.
The SPI bus master device is accessed and controlled via internal I/O registers.
Flexible data unit sizes: 8,16,24,32-bit, or variable length 1-32 bits.
Write-only mode, Read-only mode or Write-Read mode.
Programmable clock polarity modes. Programmable or automatic SPI bus Chip-Select.
For optimum pin utilization, SPI bus pins can be rerouted to any IOTester pin not used by the
external bus or other internal IOTester devices.
|
|
Serial I2C bus
|
One or more I2C bus slave devices can be connected to the external I2C bus.
The I2C bus master device is accessed and controlled via internal I/O registers.
Fast / Slow speed modes. Automatic generation of I2C start and stop signal sequences.
Support for clock stretching request from I2C slave devices.
For optimum pin utilization, I2C bus pins can be rerouted to any IOTester pin not used by the
external bus or other internal devices.
|
|
Interrupt Input
|
The IOTester interrupt input pin can be connected to interrupt from peripheral I/O devices.
Interrupt events can be serviced by interrupt functions in the "embedded application" running on the PC.
Programmable edge polarity. Can detects and latch even very short interrupt pulses.
|
|
RGB display bus
|
For direct connection of displays modules that use a RGB bus interface (TFT, OLED, etc).
The RGB display controller device is controlled via internal I/O registers.
Programmable pin layout modes: RGB18 {6:6:6} or RGB24 {8:8:8}.
Programmable display image size up to 1024 x 1024 pixels, 24 or 32 bit pr pixel.
Programmable RGB bus clocks. Pixel clock, Hsync, Vsync, Data Enable.
Programmable PWM signal for back-light control (0-100% duty-cycle)
The RGB display image is stored in the internal frame buffer. 16 Mbytes.
The content of the internal frame buffer is operated as one linear I/O register array
with fast update directly from the embedded program application on the PC.
Built-in fill and copy accelerator. Fast swap between image buffers. Flicker-free update.
|
|
Touch screen inputs
|
A 4-wire resistive touch screen can be connected directly to IOTester pins.
The touch screen device is controlled via internal I/O registers.
Detects relative X,Y positions for touch position.
Detects touch-down, touch-drag, touch-up events. Each event type can be configured to generate interrupt.
|
|
Internal IOTester® devices
|
|
Emulate typical embedded I/O devices
|
In addition to its external pin functionality IOTester-USB includes a number of internal I/O devices to
facilitate the emulation of the most common embedded I/O peripheral devices, without the need to connect such I/O peripheral hardware to the external bus.
|
|
Timer
|
Programmable 16-bit down counter. Decrements every 10 ms. Programmable start value. Can be configured to generate interrupt on terminal count.
Operates in either "single-count mode", or in "repeated-count mode" with automatic counter reload.
|
|
Interrupt controller
|
This routes interrupts from I/O peripherals to the PC for service by interrupt functions in the "embedded" PC application.
Allows enable / disable of PC interrupt generation from the various interrupt sources.
Latches and delays interrupt events while using IDE single step.
|
|
Interrupt pin event counter
|
Counts number of events on the interrupt pin. Enables the interrupt pin to be used as a hardware event counter.
Can be used to detect lost interrupts if a matching software count value is maintained in the PC interrupt function.
|
|
Timestamp counter
|
32-bit free-running timestamp counter. Incrementing every 1 ms.
Can be used for application-controlled timing measurements. Can be used as timestamp mark for profiling.
Can be used as a polled timer for the simple generation of accurate delays in the "embedded" PC application.
|
|
Links
|
|
C source examples
|
Example 1: Start using IOTester I/O port pins - "Single chip mode"
Example 2: Enabling the External bus
Example 3: Using Internal Devices and External bus.
Example 4: Using Target Interrupt.
Example 5: Writing portable I/O driver source code with <iohw.h>
Example 6: <iohw.h> implementation methods and definition of I/O registers
Example 7: Swapping source code between PC and target platforms
|
|
Display driver libraries
|
IOTester® provides direct support of RAMTEX display driver libraries:
|
|
IOTester-LPT compatibility
|
The IOTester-LPT development tool provides access to embedded I/O peripheral devices via the PC-LPT port.
The IOTester-USB functionality is a superset of the old IOTester-LPT functionality.
IOTester-USB contains an internal set of IOTester-LPT compatibility registers.
This enables direct reuse of existing IOTester-LPT source codes with IOTester-USB.
|