[Date Prev][Date Next][Thread Prev][Thread Next] - [Date Index][Thread Index][Author Index]

Re: IPS for Linux or Java

"Frederick M. Spinner" wrote:

> Oh, come on guys.. someone needs to write a 1802 IHU *EMULATOR* for Linux
> (not Windoze, darn it!).  That's the real mans way to have an "Oscar" on
> your desk!  If they can emulate a GameBoy on a Palm Pilot (which they do),
> this should be a piece of cake.

Boy -- this sounds like a solution in search of a problem If I ever saw
one! If people are really interested in trying/using/experimenting with
IPS, I again advise that you read James's versions of Karl's IPS Bible.

As Bdale noted, the very core of IPS is based on the specifics of the
hardware on which IPS is intended to run and on the application it is
intended to perform. I'll give a few specifics.

In common usage (AFIK) all the IPS implementations have been based on
having a 50 Hz clock interrupt. On transmit, the 400 BPS data clock is
assumed to be synchronous with 50 Hz clock. The terrestrial versions (again
AFIK) assumed that a 1024 byte chunk of memory was directly mapped to a 64
char x 16 line video display.

For memory efficiency (and to make the performance be usable on a [by
modern standards] slow 1802), the inner guts of IPS are contained in a
small native coded kernel that handles hardware interfaces, defines the
memory model and defines a few "core" instructions (like store, get,
push/pop/roll the stack, bit shifts, etc). 

The rest of IPS is written in high level IPS itself. This added code
includes many critical real-world operations like multiply/add/divide, view
text, define constants&variables, but these are machine independent because
they are compiled as high-level IPS instrunctions from IPS. 

The "value added" software also contains a huge amount of application
specific code: 
 - The spacecraft versions include a Keplerian model that predicts 
   where the earth is based on sun/earth sensors, pulsing the 
   magnetorquers, firing the motors, activiating transponders at 
   a particular MA, etc; 
 - A command station version might do tasks like pointing the antenna,
   and turning on the uplink xmtr; 
 - Karl's original version was used for automated train testing in 
   Germany in the late 1970's. 
 - The 8080 version done in the US in ~1980 added support for a now
   disk system and a really antiquated special-purpose S-100 hardware
And all this stuff runs as a real-time, multi-tasking system in (less than)
16-bit memory space.

Rather than trying to build a JAVA-based 1802 emulator to run on a Pentium
running Linux (or Windoze or ??) or a PowerPc (running OS-X) to then run
the IPS virtual machine seems to me to be rather counterproductive!
Wouldn't it be better to write an IPS (or FORTH -- they are virtually
equivalent) kernal directly in a few hundred JAVA (or C++ or VisualBasic or
QuickBasic or whatever) instructions. After building this small kernel, you
then use IPS as it was intended: 
 - First, use IPS to compile the rest of IPS. 
 - Second, use this IPS to compile whatever you want in application code.

So again I stress that you learn a bit more about IPS, and figure out what
you want to do with IPS, before you start designing ways to re-engineer
IPS! The definitive "What is this IPS stuff anyway?" reference is the
Karl/James book available (for ~$40 depending on where you live) from James


In addition to an erudite explanation of the IPS paradigm, you will find
sample source code for the kernel, plus the IPS code to build the IPS core.
The rest is up to you.

73, Tom
Via the amsat-bb mailing list at AMSAT.ORG courtesy of AMSAT-NA.
To unsubscribe, send "unsubscribe amsat-bb" to Majordomo@amsat.org