- The document discusses implementing a system to stream live data from simulation software to a streaming server in real-time to improve engineering education through remote collaborative experiments. It explores using hooking/function injection, TCP/IP sniffing, and an input plugin for a streaming producer but finds each method challenging to implement due to limitations of the simulation programs, operating system, or dependencies. The goal of real-time streaming of both the software and experiments has proven difficult to achieve.

1. Streaming Live Data from a Simulation Software to a Streaming Server in Real-Time
Olmo Maldonado Undergraduate Research Assistant
Department of Mechanical Engineering, the University of Texas at San Antonio
Real-Time Experiments Merged Online for Tomorrow's Engineers ( REMOTE )
A collaboration between the University of Texas at San Antonio (UTSA) and Pan American
(UT PanAm)
Funded by the National Science Foundation (NSF) Course, Curriculum, and Laboratory Innovation
(CCLI) Grant
We have begun implementing an environment to improve education in the area of System Dynamics and
Controls by using Web technology to:
Create collaborative, inter-campus laboratory experiments and simulation activities
Enhance conceptualization and use of fundamentals through multiple means of visualization
Increase participation through improved dissemination, accessibility, and availability of
experiments via the Internet to students at many institutions
Engage students collaboratively to improve understanding of system dynamics
Enable resource sharing between campuses.
So far:
- TCP/Sniffing is limited by Windows. Since the loopback device is not supported by
WinPcap because of Windows limitation, packet capturing is improbable unless we use
a NIC to transfer the data to another computer.
- Hooking implementation is delayed due to the difficulty of process injection or dll
hooking.
- The input plug-in is delayed because it depends on how the data will be sampled.
Materials: Legend:
- Web camera - RTX - item is independent on the system
- Quanser Wincon Client - MATLAB R12.1+ - Item is dependent on the system
- Quanser Wincon Server - Helix DNA Server
- Simulink - Helix DNA Producer
- Windows XP - Helix DNA SDK
- Windows Platform SDK - WinPcap
Methods:
- Hooking or Function Injection
All processes running behind the active desktop of the user are added to an internal address table that is local to the
operating system only. This internal address table keeps track of what functions each process uses and requires.
The addresses in the table can be overridden to point to a different location in memory. The result would be a
redirection of calls and routines to another program. Thus, creating a handle to any process that one can extend
or limit of the running process. The procedure is quite an undertaking because the programs that handle the real-
time extension and data sampling run more than one process and also in multi-threading format. Therefore, when
the operating system calls a certain function which runs the injected function, the injected function must perform
like the regular function while at the same time extending it’s purpose to what we require.
- TCP/IP Sniffing
Initially this method appeared to be the most feasible out of the three. At first the intentions were to sniff, or sample
the packets passed along to the Loopback device, better known as the 127.0.0.1, to a certain port in the device.
The solution required the assistance of an open-source software WinPcap. At the time, researching through the
development of sample capturing lead me to a halt when the documentation described that the Loopback device
in Windows operating systems was not supported in the program. This halted all direction in this method and
rather moved on to Hooking and function injection. Nevertheless, however, the last option to us the TCP/IP
sniffing is to install an extra Network Interface Card (NIC), send the data through the NIC to another computer,
serving as the workstation to run the real-time streaming. This option, however, is not in the scope of the
research due to time limitations.
- Input plug-in for Helix DNA Producer
At first the scope of the research became engulfed in learning which method that will work to grab the data as it was
being passed from program to program. Also involved, however, in the last steps of the whole fiasco is to
establish a system that will process the data sent from the other programs so that it can be broadcasted to the
students. At first the solution became quite clear that an input plug-in would be required. In simplest terms the
plug-in will assume that the simulation software is a web camera. This implements the need of a grab buffer, read
sample, write sample, and so on. While difficult at first, the Software Development Kit provided by the Helix
community shows a range of examples that can be used to implement this method. At the moment,
however, progress on this area of the research is stalled due to difficulties with the data exchange among
software.
Trying to sample data that is restricted to a user is extremely challenging. At first sampling the
simulation program will not work due to all the data is being sent to another software and the data is
locked from reading.
Second solution to sniff or sample the packets as they were shared among the Loopback device is a
false hope since the programming utilities lack support for the loopback device because of Windows
limitations.
Since hooking is an advanced topic in the area of Computer Engineering and Science. The results
reflect a void resolution to the problem. So far, however, the implementation of an injection system is
the most feasible.
BACKGROUND
PURPOSE AND HYPOTHESIS
MATERIALS AND METHODS RESULTS
CONCLUSIONS
BIBLIOGRAPHY
One of the necessities of the REMOTE project is to make the student comfortable with the online
experience. To emulate the work done in the classroom we want to create an environment that will seem
just like if the student was in front of the computer.
Therefore the need for a streaming broadcast of both the software used and experiments was needed.
The process of sending the data from third party software to a server is a arduous process to keep data
organized and in real-time. I predict, however, that the process can be simplified by hooking, or inserting,
our own defined functions that replace most of the common calls done in the system. This will enable the
server to receive and encode the data to be recorded and displayed in real-time.
• Helix DNA Producer and Server ( http://www.helixcommunity.org )
• Quanser Software and Experiments ( http://www.quanser.com )
• MATLAB and Simulink ( http://www.mathworks.com )
• SAMS Teach Yourself C++ in 21 Days Authors: Jesse Liberty and Bradley Jones 5th Ed. SAMS
• PHP and MySQL Web Development Authors: Luke Welling, Laura Thomson 3rd Ed. Developer’s Library
• PHP Advanced Author: George Schlossnagle Developer’s Library
• Hooking API, examples
http://www.codeproject.com/system/hooksys.asp
http://www.Planet-Source-Code.com/vb/scripts/ShowCode.asp?txtCodeId=9553&lngWId=3
• REMOTE Website ( http://remote.engineering.utsa.edu )
• NSF ( http://www.nsf.gov )
Expected Results
Multicast and Network Layout Input and Encoding Process