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

Display driver libraries

IOTester^® provides direct support of RAMTEX display driver libraries:

•   S1D13706 family library + Generic driver for microprocessors with on-chip graphic display controller. (Color)
•   S6D0129 family library (Color)
•   SSD1339 family library (Color)
•   S1D13700 family library (B&W + Grey-scale)
•   SSD0323 family library (Grey-scale)
•   ST7528, ST7529, family library (Grey-scale)
•   UC1611 family library (Grey-scale)
•   STV8105 family library (Grey-scale)
•   T6963 family library (b&w)
•   KS0108B, KS0107B family library (b&w).
•   SED1335, S1D13700 family library (b&w)
•   KS07xx family library (b&w)
•   SED1520 family library (b&w)
•   LC7981 family library (b&w)

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.