1. INtime Overview Real-time for Windows
Real-Time for Microsoft Windows

2. Time-critical Applications On Windows Platforms
INtime Overview
Time-critical Applications On Windows Platforms
What are your options?
Loosely coupled RTOS…
Costly HW & SW solutions
Limited & slow IPC options
INtime 3.0
Real-time for Windows
Real-Time for Microsoft Windows

3. Time-critical Applications On Windows Platforms
INtime Overview
Time-critical Applications On Windows Platforms
What are your options?
Loosely coupled RTOS…
Costly HW & SW solutions
Limited & slow IPC options
Kernel-mode driver…
Restricted extensibility
Never intended for large apps
Difficult to debug and test
Real-time bugs crash Windows
INtime 3.0
Real-time for Windows
Real-Time for Microsoft Windows

4. Time-critical Applications On Windows Platforms
INtime Overview
Time-critical Applications On Windows Platforms
What are your options?
Loosely coupled RTOS…
Costly HW & SW solutions
Limited & slow IPC options
Kernel-mode driver…
Restricted extensibility
Never intended for large apps
Difficult to debug and test
Real-time bugs crash Windows
…there is a better way
INtime 3.0
Real-time for Windows
Real-Time for Microsoft Windows

5. Tightly Coupled is the Superior Real-time Windows Solution
INtime Overview
Tightly Coupled is the Superior Real-time Windows Solution
Simpler inexpensive hardware
Unified development tool set
Windows-like API for real-time
Superior IPC options & tools
Simplified integration
The values associated with hosting both Windows and real-time on a single hardware platform are many:
hardware is substantially simplified and, therefore, costs less
a single unified development tool set improves developers’ efficiency because they need to master only a single development environment and utilize APIs that share common
conventions and concepts
IPC (Inter-Process Communication) is not limited to TCP/IP packets via two TCP/IP stacks, it can utilize tightly-linked message passing, semaphores, and shared memory
Integration is improved since systems can be made smaller
Real-time for Windows
INtime 3.0
Real-Time for Microsoft Windows

6. INtime Overview Two OS environments share a single hardware platform
Integrated development with Microsoft Visual Studio
INtime kernel is a full real-time operating system (RTOS)
Not a clever device driver
Windows applications have access to INtime objects
Many IPC options between Windows and RT processes
Mailboxes, semaphores, shared memory, and TCP/IP
Broad real-time I/O device support
Ethernet, TCP/IP, USB, SCSI, multi-channel serial
CAN, Profibus, DeviceNet, GPIB, EtherCAT
Delta Tau and MEI motion controllers
INtime 3.0
Real-time for Windows
Real-Time for Microsoft Windows

7. Virtual Machine Architecture
INtime Overview
Virtual Machine Architecture
Start with standard Windows
Normal Processes
Win32 API
INtime is a tightly-coupled hard real-time extension for Microsoft Windows. It does not require special hardware, but runs on any standard PC-compatible x86 system that supports the Windows operating system. INtime contains an independent RTOS that shares the PC-compatible machine and resources with Windows NT 4.0, Windows 2000 or the Windows XP operating system.
In order to accomplish this “sharing of resources,” INtime encapsulates the entire Windows operating system environment and places it as the lowest priority task within the multi-priority RTOS environment. Windows is unaware of this encapsulation process and, therefore, believes it is in complete control of the machine. Windows’ priorities and processes run unchanged, “everything Windows” is encapsulated: kernel, drivers, I/O, page tables, memory management, interrupts, processes, threads, user interface, file system…
Because the Windows kernel and all of its processes, threads, and drivers are running as the lowest priority thread in the system, INtime real-time threads will always preempt any and all running Windows threads, guaranteeing determinism for your real-time activities within the system.
INtime real-time threads and Windows threads can share sections of memory allocated by real-time applications or transfer information using messages via INtime mailboxes. In the case of shared-memory, a Windows thread obtains a handle for the shared memory and maps that memory into the Windows thread’s address space.
Isolation between the real-time segment of the system and the Windows segment is enforced by the Pentium CPU. Thus, two distinct, parallel, and isolated operating system environments exist on one CPU. To insure maximum reliability and simplify development and debugging, INtime processes and drivers always run at the most secure level of the CPU: user mode (ring 3).
Windows OS
Windows Kernel
Standard HAL
INtime 3.0
Real-time for Windows
Real-Time for Microsoft Windows

8. Virtual Machine Architecture
INtime Overview
Virtual Machine Architecture
Start with standard Windows
Partition memory and I/O resources
Add a full-featured real-time OS
Virtual machine isolates dual OSes
Normal Processes
Real-time Processes
Win32 API
INtime Real-time API
INtime is a tightly-coupled hard real-time extension for Microsoft Windows. It does not require special hardware, but runs on any standard PC-compatible x86 system that supports the Windows operating system. INtime contains an independent RTOS that shares the PC-compatible machine and resources with Windows NT 4.0, Windows 2000 or the Windows XP operating system.
In order to accomplish this “sharing of resources,” INtime encapsulates the entire Windows operating system environment and places it as the lowest priority task within the multi-priority RTOS environment. Windows is unaware of this encapsulation process and, therefore, believes it is in complete control of the machine. Windows’ priorities and processes run unchanged, “everything Windows” is encapsulated: kernel, drivers, I/O, page tables, memory management, interrupts, processes, threads, user interface, file system…
Because the Windows kernel and all of its processes, threads, and drivers are running as the lowest priority thread in the system, INtime real-time threads will always preempt any and all running Windows threads, guaranteeing determinism for your real-time activities within the system.
INtime real-time threads and Windows threads can share sections of memory allocated by real-time applications or transfer information using messages via INtime mailboxes. In the case of shared-memory, a Windows thread obtains a handle for the shared memory and maps that memory into the Windows thread’s address space.
Isolation between the real-time segment of the system and the Windows segment is enforced by the Pentium CPU. Thus, two distinct, parallel, and isolated operating system environments exist on one CPU. To insure maximum reliability and simplify development and debugging, INtime processes and drivers always run at the most secure level of the CPU: user mode (ring 3).
Windows OS
INtime Real-time Kernel
Windows Kernel
Standard HAL
INtime 3.0
Real-time for Windows
Real-Time for Microsoft Windows

9. Virtual Machine Architecture
INtime Overview
Virtual Machine Architecture
INtime Real-time Windows Application
Start with standard Windows
Partition memory and I/O resources
Add a full-featured real-time OS
Virtual machine isolates dual OSes
Bridge INtime and Windows with NTX
Normal Processes
Real-time Processes
Win32 API
INtime NTX API
INtime Real-time API
INtime is a tightly-coupled hard real-time extension for Microsoft Windows. It does not require special hardware, but runs on any standard PC-compatible x86 system that supports the Windows operating system. INtime contains an independent RTOS that shares the PC-compatible machine and resources with Windows NT 4.0, Windows 2000 or the Windows XP operating system.
In order to accomplish this “sharing of resources,” INtime encapsulates the entire Windows operating system environment and places it as the lowest priority task within the multi-priority RTOS environment. Windows is unaware of this encapsulation process and, therefore, believes it is in complete control of the machine. Windows’ priorities and processes run unchanged, “everything Windows” is encapsulated: kernel, drivers, I/O, page tables, memory management, interrupts, processes, threads, user interface, file system…
Because the Windows kernel and all of its processes, threads, and drivers are running as the lowest priority thread in the system, INtime real-time threads will always preempt any and all running Windows threads, guaranteeing determinism for your real-time activities within the system.
INtime real-time threads and Windows threads can share sections of memory allocated by real-time applications or transfer information using messages via INtime mailboxes. In the case of shared-memory, a Windows thread obtains a handle for the shared memory and maps that memory into the Windows thread’s address space.
Isolation between the real-time segment of the system and the Windows segment is enforced by the Pentium CPU. Thus, two distinct, parallel, and isolated operating system environments exist on one CPU. To insure maximum reliability and simplify development and debugging, INtime processes and drivers always run at the most secure level of the CPU: user mode (ring 3).
Windows OS
INtime Real-time Kernel
NTX DLL and VM Interface
Windows Kernel
Standard HAL
INtime 3.0
Real-time for Windows
Real-Time for Microsoft Windows

10. Proven History of Real-time for Windows
INtime Overview
Proven History of Real-time for Windows
Long history of reliable real-world use
Millions of world-wide installations
RTOS market presence for over 25 years
iRMX III in 1980
iRMX for Windows in 1992
INtime 1.0 launched in 1997
Trusted Intel and Microsoft partner
Embedded Microsoft partner since 1998
Microsoft Partner of the Year ‘04, ‘05, and ‘06
Intel Communications Alliance Member of the Year in 2006
INtime 3.0
Real-time for Windows
Real-Time for Microsoft Windows

11. Performance and Reliability
INtime Overview
Performance and Reliability
Hard real-time performance
Interrupt latency <4 µsec worst case (dual-core)
System clock rates down to 50 µsec (dual-core)
Dependable inter-process (application) isolation
User-mode application space (ring 3) for real-time apps
No real-time performance penalty for ring 3 operation
Priority inversion protection for real-time threads
Direct access to I/O and non-paged (physical) memory
Real-time network stacks, drivers, and interfaces
Distinct real-time safe C and C++ libraries
Non-destructive real-time fault handling
Minimal impact on Windows performance
INtime 3.0
Real-time for Windows
Real-Time for Microsoft Windows

12. System Performance Data
INtime Overview
System Performance Data
“Interrupt handler” data represents time measured from moment PCI interrupt line is asserted to time at which the real-time interrupt handler begins to run. “Interrupt thread” data represents time measured from moment PCI interrupt line is asserted to time at which the real-time interrupt service thread (IST) begins execution.
An “idle system” is a standard Windows XP Pro at a default login, where the System Idle process consuming virtually all CPU cycles. A “busy system” contains multiple running applications, including at least the following activities: searching for a text string inside files on the hard disk, copying a very large file to an ftp server, playing MP3 audio clips with Windows Media Player, and displaying an AVI file with a DIVX video player.
Bounded response to interrupts is key to the definition of a hard real-time system. Real-time systems require determinism for predictable behavior of the system (necessary requirements in order to classify a system as “observable” and “controllable”). Without determinism a system cannot be classified as real-time. Without bounded determinism a system cannot be classified as hard real-time.
The level of determinism required of a real-time system is a function of the frequency of real-time events in the system (size of the time interval between events) and the effect of delay on the dynamics of the system. That is, how frequently do events occur and how quickly must the system respond to those events when they do occur. Being able to place a finite boundary on the value of these numbers is what distinguishes a hard real-time system from other systems.
Faster processors, memory, and peripherals improve the aggregate performance of a system, but they do not directly affect the bounded determinism of a system. The worst-case response time to an event will not be changed by using a faster processor; it may decrease the frequency of the worst-case response time or worst-case jitter, but it will not eliminate the worst-case jitter.
Improving performance (or speed) of a system is a useful thing, because it increases the complexity of the algorithms one can implement and, therefore, the quality of the control and data acquisition systems one can implement in software. However, bounded determinism is still required to insure that a stable and accurate system, regardless of the performance level, can be deployed.
In addition to providing a bounded deterministic operating environment, INtime software simplifies the creation of machine control software. Applications written for the INtime environment have direct access to I/O, specialized drivers are not required. Furthermore, the support libraries and modules that are included with the INtime software package are designed specifically for use in a hard real-time environment.
Real-time for Windows
INtime 3.0
Real-Time for Microsoft Windows

13. INtime Real-time Applications
INtime Overview
INtime Real-time Applications
Industrial Control
Robotics
Motion Control
Medical Imaging
Test & Measurement
CNC Machining
Material Handling
Process Control
Radar & Avionics
Simulation
INtime 3.0
Real-time for Windows
Real-Time for Microsoft Windows

14. X-Ray Equipment Major supplier of medical X-ray systems
INtime Overview
X-Ray Equipment
Major supplier of medical X-ray systems
Mission critical application for real-time
TenAsys technology used throughout
INtime & Windows control system console
Remote INtime nodes running autonomously
CANbus connects real-time INtime nodes
Philips Medical Eleva series:
EasyDiagnost
MultiDiagnost
OmniDiagnost
INtime 3.0
Real-time for Windows
Real-Time for Microsoft Windows

15. INtime Overview
X-Ray Equipment
“We use INtime for those areas of the system where movements are controlled and where radiation is controlled.”
“Those are two areas where we need the most reliable software.”
Sven Kuehl Software Project Leader
X-Ray Equipment Application
Application note available on the TenAsys web-site. “Philips Medical Systems Chooses INtime for Critical Real-Time Control”
Major supplier of medical X-ray systems
Mission critical application for real-time TenAsys technology used throughout
INtime & Windows control system console Remote INtime nodes running autonomously CANbus connects real-time INtime nodes
Philips Medical Eleva series:
EasyDiagnost MultiDiagnost OmniDiagnost
Real-time for Windows
INtime 3.0
Real-Time for Microsoft Windows

16. Test and Measurement World leader in power train engineering
INtime Overview
Test and Measurement
World leader in power train engineering
PUMA test bed
Utilizes INtime remote nodes
High performance data acquisition system
IEEE 1394 (real-time) backbone
Up to 5 kHz continuous sampling rate
AVL real-time research paper
“Thread-based analysis of embedded applications with real-time and non real-time processing on a single platform”
Graz University of Technology
INtime 3.0
Real-time for Windows
Real-Time for Microsoft Windows

17. INtime Overview
Test and Measurement
“We already use Windows for visualization and database management. Why not use the same platform for critical real-time constraints?”
“Plus, this would mean no additional hardware system costs for our customers.”
Bernhard Hochstrasser Software Development Engineer
Embedded Test Application
Application note available on the TenAsys web-site. “TenAsys Helps Capture Engine Control Data for AVL”
World leader in power train engineering
PUMA test bed Utilizes INtime remote nodes
High performance data acquisition system
IEEE 1394 (real-time) backbone Up to 5 kHz continuous sampling rate
AVL Real-time research paper
“Thread-based analysis of embedded applications with real-time and non real-time processing on a single platform” ftp://
Real-time for Windows
INtime 3.0
Real-Time for Microsoft Windows

18. Industrial Control Largest supplier of Soft PLC systems
INtime Overview
Industrial Control
Largest supplier of Soft PLC systems
Lowers cost to customers by using industrial grade PC
Exceeds performance of hard PLC systems
Steeplechase VLC is used in:
Steel mills
Automotive assembly
Packaging
Materials handling
INtime 3.0
Real-time for Windows
Real-Time for Microsoft Windows

19. INtime Overview
Industrial Control
“The fact that the TenAsys product was a solid platform was very important. It had a history before we started looking at it.”
“TenAsys is proven technology.”
Jeff Fisher Global Product Manager
Industrial Control Application
Application note available on the TenAsys web-site. “Entivity VLC Achieves Factory-Floor Stability With INtime Real-Time Operating System”
Largest supplier of Soft PLC systems
Lowers cost to customers by using industrial grade PC Exceeds performance of hard PLC systems Standard fieldbus support
Entivity VLC is used in:
Steel mills Automotive assembly Packaging Materials handling
Real-time for Windows
INtime 3.0
Real-Time for Microsoft Windows

20. CNC Machining World leading CNC tool vendor
INtime Overview
CNC Machining
World leading CNC tool vendor
Two generations of machine tools on INtime since 2000
Servicing automotive, medical device, special tool grinding, gear grinding, and aerospace markets
High-precision and high-speed
5-axis direct drive systems
3 microns precision
12,000 RPM spindle
3D preview and display
INtime 3.0
Real-time for Windows
Real-Time for Microsoft Windows

21. INtime Overview
CNC Machining
“We ported from QNX to INtime using a ‘shim’ to maximize preservation of existing control code.”
“That code was up and running relatively quickly and continues to work today.”
Gerard Cullen CNC Software Developer
Industrial Control Application
Application note available on the TenAsys web-site. “Entivity VLC Achieves Factory-Floor Stability With INtime Real-Time Operating System”
Largest supplier of Soft PLC systems
Lowers cost to customers by using industrial grade PC Exceeds performance of hard PLC systems Standard fieldbus support
Entivity VLC is used in:
Steel mills Automotive assembly Packaging Materials handling
Real-time for Windows
INtime 3.0
Real-Time for Microsoft Windows

22. TenAsys Real-time Customers
INtime Overview
TenAsys Real-time Customers
ABB Robotics
Abbott Laboratory equipment
Allen-Bradley Industrial Automation
AVL List Automotive
Bell & Howell Imaging
Besi Die (Laurier) Semiconductor handling
Boeing Aerospace
Carl Zeiss Planetarium systems
General Dynamics Electric Boat Corporation Military
EADS Military
Eaton Cutler-Hammer Industrial Automation
Entivity, Inc Industrial Automation
ESI (Beaverton) Industrial Automation
GE Medical
Lockheed Martin Aerospace
Mettler-Toledo Laboratory equipment
Northrup Grumman Aerospace
Opex Corporation Imaging
Philips Medical Systems Medical systems
Robotics Research Robotics
Siemens Various
Real-time for Windows
INtime 3.0
Real-Time for Microsoft Windows

23. INtime 3.0 Key Features Microsoft Visual Studio integration
INtime Overview
INtime 3.0 Key Features
Microsoft Visual Studio integration
Integrated real-time debugger
NTX object for all .NET languages
Multi-core processor support
Intel Core Duo CPUs
All standard Windows SMP platforms
Breadth of real-time device drivers
Real-time USB, Ethernet, and industrial I/O devices
Fault and spin managers
Fault manager directs real-time faults to VS debugger
Spin detector suspends threads that monopolize CPU cycles
Windows 2000, Windows XP, and Windows Vista
Windows XP Embedded and variants (POS, etc.)
Windows 2003 Server
INtime 3.0
Real-time for Windows
Real-Time for Microsoft Windows

24. Why Choose INtime? Deterministic real-time control for Windows
INtime Overview
Why Choose INtime?
Deterministic real-time control for Windows
Reliable and secure run-time environment
Integration with Visual Studio for development and debug
Support for all standard Windows hardware platforms
Management of real-time faults without machine lockups
Connection via real-time TCP/IP, USB, and fieldbus
Persistent application execution for fail-safe operation
Practical use of hardware and software resources
Field-proven kernel, libraries, drivers, and applications
Trusted Microsoft and Intel embedded partner
Deterministic Reliable Full-Featured Connected Persistent Proven Practical
Real-time for Windows
INtime 3.0
Real-Time for Microsoft Windows

25. INtime Overview Details
Real-time for Windows
Details
Real-Time for Microsoft Windows

26. Multi-Processor Support
INtime Overview
Multi-Processor Support
Operate on all Microsoft multi-processor HALs
Validated on P3, P4, Xeon, and Core™ CPU platforms
Windows multi-processor SMP and multi-core systems
Intel Core™ and Hyper-Threading processors
Multi-core operating modes:
Real-time performance (exclusive) mode
INtime RTOS is dedicated to a single core
Remaining CPU cores are dedicated to Windows
Windows performance (shared) mode
INtime shares one CPU core with Windows
INtime 3.0
Real-time for Windows
Real-Time for Microsoft Windows

27. Multi-Core Processor Benefits
INtime Overview
Multi-Core Processor Benefits
Dedicate a single CPU core to real-time processes
Complete isolation of real-time interrupts
Minimal impact on Windows performance
Maximize performance of real-time processes
Or share CPU cycles between INtime and Windows
Optimize Windows’ use of multiple CPU cores
Maximize CPU cycles available to Windows
Both modes include enhancements to determinism
Better isolation of real-time interrupts
Significant decrease in real-time interrupt delays
Independent real-time clock (more precise timer ticks)
Minimal interaction with Windows HAL
INtime 3.0
Real-time for Windows
Real-Time for Microsoft Windows

28. Visual Studio Integration
INtime Overview
Visual Studio Integration
Develop real-time code in Visual Studio environment
C/C++ and x86 assembly
INtime Wizards generate real-time code templates
VS 2003 and VS 2005
Real-time source-level debugging
No simulation step required
Simultaneously debug real-time and Windows applications
Windows apps use NTX interface
Either .h files or .NET object
Visual Studio solutions contain INtime and Windows projects
All development is performed within the familiar Visual Studio IDE. Two real-time debuggers are available: a stand-alone debugger called Spider and a Visual Studio debugger plug-in. The Visual Studio debugger plug-in dramatically improves the efficiency of debugging and developing INtime real-time applications because it allows one to use the familiar Visual Studio interface to trace and step through INtime real-time code.
Because all real-time threads run in user mode or ring three, the debugger features available for monitoring and inspecting real-time threads are nearly identical to those found in the standard Visual Studio debugger. This is also the reason that debugging an INtime real-time application does not require a simulation step. When you develop and debug an INtime real-time application you do so on the same real-time kernel and in the same environment in which you will deploy your final application. There is no question as to whether or not you have tested the final application, because there is only one development and run-time environment.
Wizards have been integrated into Visual Studio to generate real-time code templates for typical real-time applications. These wizards generate usable and compilable code that then can be used as the starting point for writing a complete application.
Real-time for Windows
INtime 3.0
Real-Time for Microsoft Windows

29. Visual Studio Debugging
INtime Overview
Visual Studio Debugging
Integrated real-time debugger
Use Visual Studio to debug real-time processes and threads
Not possible with device driver solutions
Display and modify variables
Breakpoints, single-step, etc.
INtime 3.0
Real-time for Windows
Real-Time for Microsoft Windows

30. Visual Studio Debugging
INtime Overview
Visual Studio Debugging
Integrated real-time debugger
Use Visual Studio to debug real-time processes and threads
Not possible with device driver solutions
Display and modify variables
Breakpoints, single-step, etc.
Real-time process fault manager
Fault in real-time thread:
suspends thread and process
launches VS debug session
or launches Spider debugger
Log trace on deployed systems
INtime 3.0
Real-time for Windows
Real-Time for Microsoft Windows

31. INtime Overview
INtime Device Drivers
Partial list of available real-time device drivers:
RS-232 serial, SCSI, VGA, USB serial, IEEE-488 (GPIB)
Intel, 3Com, NE2000, and Realtek Ethernet controllers
Hilscher CIF/COM fieldbus controllers
Communication interfaces
DeviceNet, PROFIBUS, CANopen, ControlNet
EtherCAT deterministic fieldbus
Real-time TCP/IP and USB stacks
TCP/IP stack on real-time kernel
No Windows overhead
Standard sockets API
A wide variety of real-time Ethernet drivers is available for use with INtime applications. These drivers are developed and supported by TenAsys directly. A real-time USB stack has also been developed to allow direct access to USB peripherals within the real-time application environment. Please call or check our web-site for a complete list of supported real-time hardware.
INtime real-time applications have direct access to a dedicated real-time TCP/IP stack without requiring Windows as an intermediary. Standard sockets API contains the following calls:
socket() bind() connect(), disconnect() send(), sendto(), sendmsg() receive(), receivefrom(), receivemsg() close() setsockopt(), ioctl() getsockopt() getsockname(), getpeername() listen(), accept()
Real-time for Windows
INtime 3.0
Real-Time for Microsoft Windows

32. Real-time Configuration Tools
INtime Overview
Real-time Configuration Tools
Interrupt Device Configurator
Simplifies assignment of IRQ to real-time environment
Warns of conflicts re shared Windows interrupts
INtime configuration utility
Windows control panel
Configure remote nodes
Manage interrupt resources
Memory extensions
Pre-allocate memory external to Windows
Reach > 4GBytes memory (using paging techniques)
INtime 3.0
Real-time for Windows
Real-Time for Microsoft Windows

33. INtex (INtime Explorer) Real-Time Object Browser
INtime Overview
INtex (INtime Explorer) Real-Time Object Browser
INtex is a Windows-based real-time object browser. INtex is able to show the state of all real-time processes, threads, and objects. It can also display the code (via Microsoft Developer Studio) associated with a process that has been suspended due to a hardware fault for crash analysis.
Real-time for Windows
INtime 3.0
Real-Time for Microsoft Windows

34. INScope (Software Scope) Performance Analysis Tool
INtime Overview
INScope (Software Scope) Performance Analysis Tool
Time stamp entry and exits of major API calls and interrupt handlers
Determine exact sequence and precise timing of real-time code execution
INScope is a real-time performance analyzer. It is a Windows application that allows you to trace execution of INtime applications. Trace information for thread switches, system calls, and interrupt handling is displayed in a graphical user interface with various tools available to track the sequence and timing of your real-time threads.
Real-time for Windows
INtime 3.0
Real-Time for Microsoft Windows

35. Scalable and Extendable
INtime Overview
Scalable and Extendable
Stand-alone RTOS solutions
INtime remote nodes on embedded hardware
Easily scale using XP Embedded tools
Detailed SLD included
Highly extensible platform
No system too complex
Motion
Vision
Discrete I/O
All with predictable and reliable results!
The INtime kernel (and its real-time applications) may also be installed and run on a standalone embedded platform, and connected to a Windows workstation. Such an installation is called an “INtime Remote Node.” Communication between a Windows application and a remote INtime application utilizes the same NTX interface as that used by a local INtime application, with Ethernet or a serial line as the communications medium. All the NTX calls used to communicate between Windows and real-time threads are available and work identically in this configuration, except shared memory.
Scalability of solutions is achieved by the fact that the INtime and Windows binaries you create for an “INtime Local Node” will run unmodified on a remote deployment (“INtime Remote Node”). Unlike many RTOS solutions, INtime remote nodes can be built to support single-chip 386 and 486 systems. Like Windows, many 32-bit embedded RTOS solutions today are incapable of supporting x86 processors below the Pentium level.
Real-time for Windows
INtime 3.0
Real-Time for Microsoft Windows

36. INtime Overview
Reliable Isolation
Windows Segment (lowest priority real-time segment)
INtime Real-Time Processes
(multiple real-time segments)
DATA
CODE
STACK
HEAP
thread2 data
thread2 code
thread2 stack
thread2 heap
threads3-n
arranged as above
Contains Windows kernel, drivers, memory,
applications,
etc.
DATA
CODE
STACK
HEAP
thread2 data
thread2 code
thread2 stack
thread2 heap
threads3-n
arranged as above
DATA
CODE
STACK
HEAP
thread2 data
thread2 code
thread2 stack
thread2 heap
threads3-n
arranged as above
non-allocated areas
(page fault if entered) }
additional threads allocated as above
Address isolation and protection between Windows and the real-time subsystem is accomplished via:
Separate hardware tasks Distinct descriptor tables Unique memory segments and page directories
Protection between real-time processes (or tasks) is managed by:
Real-time processes reside in private “virtual segments” Identity-mapped paging is utilized (locked-down pages)
code, data, stack, and heap are in separate, non-contiguous pages code placed in read-only pages for extra protection paging used for virtual address support only - no demand paging paging is utilized for address isolation and pointer overrun protection
A key advantage to INtime’s encapsulation approach is that real-time applications have numerous memory protection mechanisms to insure reliability and simplify debugging. This is in stark contrast to solutions which require that the real-time threads run within Window’s kernel mode, without any address isolation or memory protection between multiple real-time processes or between real-time processes and Windows processes.
Each INtime real-time process (consisting of one or more threads) is placed in its own segment (with a unique segment descriptor). Thus, each real-time process is isolated from all other processes, including the entire Windows system which occupies its own segment. If any code tries to access an address outside of its segment a general protection fault (GPF) is generated. INtime segments are referred to as “virtual segments” because they are managed transparently by the INtime virtual memory manager.
Every real-time thread is assigned pages of memory for its CODE, DATA, STACK, and HEAP memory regions. By separating these pages with non-allocated bands of memory, pointer overruns can be detected. CODE pages are further protected by marking them as read-only. The minimum size for a single page of memory is four kbytes, which is imposed by the hardware.
Virtual Segment limit (GP fault if crossed)
Real-time for Windows
INtime 3.0
Real-Time for Microsoft Windows

37. Virtualization Details
INtime Overview
Virtualization Details
CPU-enforced isolation between INtime and Windows
Two distinct, parallel, and isolated environments
INtime processes and drivers run in user mode
Windows encapsulated as lowest priority INtime task
Windows’ priorities and processes run unchanged
“Everything Windows” is encapsulated:
kernel, drivers, I/O, page tables, memory management,
interrupts, processes, threads, user interface, file system…
User-mode enforces reliable applications
Full speed, no performance penalty
Superior real-time debugging tools
INtime user-mode includes:
Direct access to I/O and memory
Memory protection for reliability
Paging turned off to insure determinism
Non-paged memory is essential to insure determinism of the INtime real-time extension. The real-time processes (or tasks) are described as residing within virtual segments for protection and reliability. This does not mean, however, that these virtual segments occupy virtual memory. All memory that is allocated for use by the INtime real-time system, and its applications, is non-paged memory.
Whenever the system switches to a real-time task or thread (e.g., as the result of a real-time event or timer activity), the real-time code is guaranteed to execute immediately from physical memory. There is no paging of the real-time kernel or any of its tasks and threads to off-line storage. All real-time code elements are guaranteed to be resident in physical memory at all times. Without this basic system rule in place there would be no way to insure that the INtime kernel and its applications were deterministic.
Additionally, there is no performance penalty for placing the real-time applications in the more reliable and protected user or ring three operating level. Code operates at exactly the same speed at this level as it does at the supervisor or ring zero level. The CPU does not distinguish between these two operating levels where performance is concerned, they only affect the ability to execute certain privileged instructions and the use of debugging tools.
Real-time for Windows
INtime 3.0
Real-Time for Microsoft Windows

38. Continuous Operation Fault and spin managers prevent lockups
INtime Overview
Continuous Operation
Fault and spin managers prevent lockups
Fault manager directs real-time faults to GPF handler
Spin detector suspends threads that monopolize CPU cycle
Unaffected processes continue to operate
STOP manager detects BSOD notifications
Real-time threads continue, unimpeded by a blue screen
Continuous operation means INtime applications can:
Operate without Windows, indefinitely
Gracefully shutdown or restart
Send a signal via an INtime communication interface (e.g., serial or Ethernet) that attention is required
Because the INtime real-time environment is a complete stand-alone RTOS, running on what is, essentially, a completely separate virtual machine, real-time applications do not need to be concerned with the dreaded BSOD (Blue Screen of Death) that occasionally befalls a Windows system. The INtime system includes a BSOD or STOP manager specifically to intercept a Windows BSOD. Real-time applications are provided with notification of a BSOD so they may take appropriate actions to deal with such an event.
The INtime kernel does not hook the HAL to implement its BSOD shutdown handler (or STOP manager). BSOD notifications are intercepted by the INtime real-time interface driver (rtif.sys) which halts the Windows BSOD process, preventing a complete shutdown of the Windows system. This allows the INtime kernel and its processes and threads to continue operating, indefinitely. Of course, any real-time threads that communicate with the Windows side of the system will be indefinitely suspended, but those threads that can operate independently of Windows can continue to do so without interruption.
Generally, detection of a BSOD by the INtime STOP manager can be used by the real-time application to gracefully shutdown or restart the system, or send a signal to some other system via a real-time controlled communication interface (e.g., serial or Ethernet) indicating that action or attention is required.
INtime software does hook the Windows HAL for the following reasons:
Intercept attempts to modify the system clock rate, insuring that the INtime kernel controls the system time base.
Manage those resources exclusive to INtime or shared with Windows.
Insure that interrupts reserved for real-time use are never masked or assigned for use by any Windows software.
The following HALs are recognized and supported by INtime software:
ACPI Multiprocessor PC (halmacpi.dll, MP ACPI APIC) ACPI Uniprocessor PC (halaacpi.dll, UP ACPI APIC) Advanced Configuration and Power Interface (ACPI) PC (halacpi.dll, UP ACPI) MPS Multiprocessor PC (halmps.dll, MP MPS APIC) MPS Uniprocessor PC (halapic.dll, UP MPS APIC) Standard PC (hal.dll, UP)
Real-time for Windows
INtime 3.0
Real-Time for Microsoft Windows

39. INtime Kernel Features (part 1)
INtime Overview
INtime Kernel Features (part 1)
Multi-tasked, multi-threaded applications
Preemptive priority-based scheduling algorithm
255 real-time priority task levels
Windows is lowest priority real-time task
Event-driven scheduling for interrupts and alarms
Round-robin scheduling for equal priority threads
Priority inheritance to avoid deadlocks
Periodic and one-shot timer events
50 µsec minimum interval (dual-core systems)
Interrupt service routines (ISR) and interrupt service threads (IST)
Real-time interrupts always preempt Windows
ISRs for very fast and simple interrupt processing
ISTs for complex, full-featured interrupt processing
The INtime operating environment is a complete RTOS. It supports multiple processes or tasks, and multiple threads within those tasks. Each thread can be assigned to one of 255 priorities. If threads share a priority level they will operate within that level according to a round-robin scheduling algorithm. Generally, scheduling is pre-emptive and accomplished as the result of responding to an event (typically an external hardware interrupt or an internal timer). When all events have been serviced, and there are no outstanding threads waiting for service, the lowest priority thread, or idle task, will be allowed to execute. Windows is that “idle task.”
Two types of interrupt service mechanisms are available. The Interrupt Service Routine (ISR) is always called in response to an interrupt. The ISR runs in an environment in which only a limited subset of INtime service calls can be made. The tradeoff for this limited system call environment is the extremely high speed of response to an interrupt, only minimum and necessary work should be done here, which may be sufficient for many interrupt handlers. If a more complete system call environment is required an Interrupt Service Thread (IST) can be utilized. The IST (when used) is scheduled for execution following completion of an ISR, but with a priority and interrupt masking level equivalent to the ISR. The expense of an IST is additional delay from the time the interrupt is asserted to the time interrupt handling code begins execution.
Real-time for Windows
INtime 3.0
Real-Time for Microsoft Windows

40. INtime Kernel Features (part 2)
INtime Overview
INtime Kernel Features (part 2)
Memory management and data sharing
Shared memory and mailboxes (message passing)
Static and dynamic memory pools and heaps
C library malloc() and free() functions
C++ new and delete operators
Synchronization mechanisms
Mailboxes (wait on messages)
Semaphores (single or multi-count)
Regions (a.k.a. critical regions or mutexes)
IPC between Windows and INtime (NTX)
Mailboxes, semaphores, and shared memory
IPC (NTX) managed by real-time kernel insures reliability
The INtime environment includes several memory management options, especially for the transfer of data between the Windows threads of an INtime application and the real-time threads. Shared physical memory is one of the most flexible mechanisms one can use between the real-time and Windows threads of an application, but applications can also utilize mailboxes and semaphores. The advantage of mailboxes and semaphores is their built-in synchronization features. Mailboxes are used to send fixed length messages. Messages can be queued and, optionally, threads can wait on an empty mailbox.
NTX is the name assigned to the interface that a Windows process or thread uses to communicate with the INtime real-time tasks and threads. The NTX interface is contained within a standard Windows DLL file.
Real-time for Windows
INtime 3.0
Real-Time for Microsoft Windows

41. INtime Kernel Features (part 3)
INtime Overview
INtime Kernel Features (part 3)
Exception handling for:
Programming errors (invalid parameters)
Invalid or insufficient resource errors (memory)
Floating point errors (numeric processor)
Hardware faults (page faults, segment faults…)
Multiple unique real-time APIs
INtime  native real-time API
iRMX  transition API for iRMX apps
iWin32  transition API for Win32 apps
RSL (real-time shared libraries)
Similar to Windows DLL, runs in user mode (ring 3)
Ideal for implementing real-time device drivers
Three APIs are available for writing INtime real-time applications: the INtime native API, the legacy iRMX API, and the new iWin32 API. When starting from scratch one would normally use the INtime API, as it provides access to the full functionality of the INtime real-time system. The iRMX and iWin32 APIs are useful when converting existing iRMX and Windows or RTX code to the INtime real-time system.
Real-time Shared Libraries (RSL) are very similar in concept to a Windows DLL. They are especially useful for creating specialized real-time device drivers, without having to comply with a forced framework. An RSL runs at user mode or ring three level, like all other INtime real-time applications.
Real-time for Windows
INtime 3.0
Real-Time for Microsoft Windows

42. INtime Overview
Proven Technology
“Intel® Virtualization Technology is a key component of our platform approach to enable new levels of performance and features for a broad range of applications. TenAsys is utilizing this technology to help bring those benefits to embedded application developers.”
Doug Davis, VP and General Manager Communications Infrastructure Group Intel Corporation
INtime 3.0
Real-time for Windows
Real-Time for Microsoft Windows

43. TenAsys Software Quietly Running the World
INtime Overview
TenAsys Software Quietly Running the World
Industrial Control & Robotics
Air & Ground Traffic Control
Medical Imaging
Test & Measurement
CNC Machining
Material Handling
Process Control
Radar & Avionics
Simulation
Mail & Check Sorting
INtime 3.0
Real-time for Windows
Real-Time for Microsoft Windows