Sigh... After having our machine abused by some mindless jerks the
disk crashed and everything since Nov of 1998 has been lost. This
is of course a major setback. Work on CAM8 software has since come
to a halt. It is uncertain when it can be resumed. Hopefully we can
offer something new this year.
Sept 9, 1998
A Solaris device driver for CAM8 is almost completed (better late than
never right :-) This should make many people happy since SunOS is dead
as far as further Sun support is concerned. Not as horrible as I
feared since Sun has worked hard trying to make Solaris stable and bug
free. The driver should be completed by the end of Sept.
July 15, 1998
Conversion of the current CAM8 library to C++ is complete and a first
level test (compiling XCAM) was sucessful. Now begins the process of
validating the C++ library.
May 5, 1998
Geesh... after a really long hiatus progress is again being made on stage two of the conversion process. Hopefully soon we'll have a C++ version of the CAM library for distribution. When this has been completed I'll take another break from the conversion process to upgrade and add to the library. There is quite a bit of usefull code that can be added.
After the upgrade I'll use the wonderfull SWIG utility to provide Python, TCL and Perl interfaces. When the SWIG interface files are completed I can begin to provide a programming environment for CAM8 in Python (I'll let someone else work on environments for TCL/TK and Perl). My goal is to replace the current Forth based STEP control program with a Python based equivalent. This should allow more people to code complex experiments for CAM8.
Some people have already found novel ways to get around the
difficulties in developing usefull code in Forth. Wojtek Burkot in
Poland has done some interesting
work interfacing CAM8 and Java.
July 26, 1997
In line with the goals of providing a robust programming environment for CAM8 users (see June 21, 1995 and Oct 19, 1995 developments below) the CAM8 library is being upgraded and converted from C to C++ (some of you cringe :-).
Stage one in the conversion process was to get the current C-based library to compile cleanly with a C++ compiler. This C++ compiled library is a drop in replacement for the C compiled one.
Stage two involves converting the library from C to C++ in a minimal way. In other words C structures used to represent abstract objects become C++ classes. Procedures that operate on the C structures become C++ member functions, etc. This is currently under way and when completed a collection of C wrapper procedures identical to the current CAMlib procedures will be designed. The C++ library will be a drop in replacement for the original CAMlib and we will distribute both.
Stage three involves completely redesigning the library incorporating new features, adopting a new programming model and switching to a more object oriented mindset. This new C++ library will include ideas and abstractions that support CA programming in general and will not be as CAM8 specific. Not to worry though because CAM8 will be fully supported by the library (and even easier to program). It will however allow people to design a CA program that will run on hardware other than CAM8 (for those who haven't been lucky enough to get one yet :-).
Stage four happens in two phases. First we will rewrite the C wrappers from stage two so that we can provide this new C++ library as a drop in replacement for the original CAMlib. These wrappers will provide the same API as the original CAMlib and will be sort of a "proof" that the new design provides all the functionality of the original. It will also give backward-compatibility for older code. Second we will recode all of our packages, that have been using the old programming paradigms, to use the new ones implemented in the new library. This will be the "official" switch to C++ and we will do all futher development using this library.
Stage five will really be the continued support and development of
CA software. We will provide a new non-Forth based interpretive
programming environment based on the C++ library (still haven't
decided which interpreter). We will use the popular SWIG interface
generator to provide an easy way of imbedding the library in TCL,
Python, Perl and Guile interpreters. We want to do this so that
people who build software based on the C++ library can get bug fixes
and upgrades by simply downloading the latest and greatest copy of the
library. Likewise we can provide upgrades to our own programming
environment simply by distributing a new library.
March 17, 1997
Another new release of the CAM8 software is available. Get the entire
release . Upgrades to CAMlib, STEP and XCAM are included.
Oct 19, 1996
An improvement has been completed which will allow external processes
to send input to STEP. This was particularly usefull in extending the
XCAM widget so that keys pressed while the mouse is in the window can
be sent to STEP. Previously users had to move back and forth between
the STEP and XCAM windows.
Aug 22, 1996
A new release of the CAM8 software, yeah! There have been major
updates to STEP, cam8sim and CAMlib. Minor changes and bug fixes for
XCAM and devdri are also included. Get the entire
release or just the pieces you
need. Dan has moved on to "greener" pastures (ie: he graduated). His
thesis involved devloping a simple CA language and compiler for CAM8
(or future CAM's as well). The things he discovered will be the basis
for future compilers and other tools for writting and debugging
complex CA rules !!
April 12, 1996
Despite multiple humble requests Dan hasn't updated this page :-( So
Harris is forced to do so even though he isn't even at LCS anymore
:-). Dan, after many hours of debugging an old version and THEN the
up-to-date version of the CAMlib libraries, has sucessfully
implemented, and executed a CAM8 experiment, writen entirely in C,
using the CAMlib libraries. Yea !! A port of the library to C++ is
almost inevitable and Python is the current front runner for a
replacement for Forth (IMHO). Dan, being the studly programmer that
he is, continues to work on a CA "language" for CAM8 for his Master's
thesis. In other news, Ruben Agin has completed the next phase of his
CA digital logic simulation. He has layed out the "Sexium" chip, a
VLSI design he did for a class at MIT, on a CA-silicon waffer. This
chip runs assembly language programs at about 1 KHz (this is
comparable to VLSI simulation packages currently running on common
workstations). The design is based on the 2D CA digital logic
experiments he did in the past. Using 3D CA digital logic would yield
faster simulated clock rates.
Oct 19, 1995
Harris has been working at Hanscom AFB since Aug and working on the
CAMlib project when he can. He has completed Alpha versions of the
"new-experiment" and "space" Forth words. A search for a interpreted
language to replace Forth has begun (anybody know where I can get a
C++ interpreter :-). Considerations include Scheme/LISP, Python,
TCL/TK and Smalltalk. The future of the CAMlib project is unclear as
it may be necessary to switch to C++ or some other object oriented
programming language. Dan continues to improve CamPat and has begun
to develop a language for describing CA rules and a compiler that will
generate an intermediate representation that can be parsed into
steplists/luts for CAM8 or possibly used on another platform. Manoj
is working on the MKW project which will provide a set of tools to
make it easier to link the CAMlib routines into other packages (such
as TCL/Tk, Python, Mathematica, etc).
June 21, 1995
Harris completes an alpha release of CAMlib -- a library of C routines for programing CAM experiments. CAMlib includes all of the functionality of the older cam8lib package with addition of the StepLib library. CAMlib provides a set of procedures that can be used in conjunction with STEP software, written in Forth, to control the CAM8 hardware. Dan's hybrid Forth/C life experiment was sucessully ported to use CAMlib. The beta release of CAMlib will include:
Manoj completes the framework for a Tcl/Tk based CAM8 programming
environment. He begins the task of providing a replacement for the
PipeComm communicatons library. The PipeComm library provides a
master/slave interface between the STEP control software and an
external C process. It is used as the means of communication between
STEP and the XCAM display utility, the CAM8 simulator and the camgen
program. Camgen was written by Jeff Yepez, one of our collaborators
with the Air Force, to generate initial conditions and analyze data
collected from his fluid dynamics experiments. PipeComm uses a simple
communications protocol over UNIX pipes. Manoj will replace Pipecomm
with a more robust and general purpose protocol/library which uses
May 30, 1995
Manoj begins work on a Tcl/Tk based programming environment for CAM8.
When completed this will provide a GUI interface for running/debugging
CAM8 expriments, generating initial conditions and
May 5, 1995
Dan uses the alpha version of his campat library to sucessfully render
two and three dimensional patterns.
May 3, 1995
Dan begins the task of reorganizing the campat utility. The routines
that render various geometric shapes are collected into a library.
The preliminary spec for a data abstraction of the CAM8 pattern files
Apr 29, 1995
Completed, in collaboration with Jeff Yepez, a Finite-Integer Lattice-Gas simulation of flow past a cylinder on the Air Force's 16M 8 module CAM8. This simulation includes two fluids:
It was run on a 2048x1024 triagular lattice with periodic boundary
conditions and demonstrates Vortex Shedding (Von Karman Instability).
A MPEG2 movie was generated
(approx. 8M long). There is also a shortened version which uses
1/4 of the frames from the full movie.
Apr 27, 1995
Harris regains interest in this page... Harris begins the job of
consolidating all of the C code, written thusfar for CAM programming,
into one library.
Mar 3, 1995
Harris and Dan lose interest in keeping this document up to
date. (Bummer! :-)
Mar 2, 1995
Dan writes C code that downloads a colormap to the CAM8 framebuffer.
Mar 1, 1995
Dan writes C code that downloads a buffer to module one of the CAM and then
displays it on the framebuffer. This is the first step in the completion
of the CAM8FBuf device driver.
Feb 26, 1995
Dan begins work on a psuedo device driver that will allow programs to
display things on the CAM8 monitor. This device driver will "pretend"
to be a framebuffer attached to the workstation. This driver (CAM8FBuf)
can be used as another display by an X Server or any program that uses
Feb 24, 1995
Harris finished a preliminary version of c8pp. Dan begins to use it with
the StepLib library and all C code he writes.
Feb 10, 1995
Harris begins work on the c8pp preprocessor which recognizes a CAM8
assembly-like language and converts it into C code to be used with the
Feb 6, 1995
Manoj Muzumdar successfully rewrites the parser of the campat utility.
Improvements in progress.
Jan 25, 1995
Dan ran the first hybrid Forth/C version of the life CA using lowlevel
primitives of the StepLib library.
Jan 15, 1995
Harris completes the first usable version of StepLib, Dan
Jan 3, 1995
Dan Risacher joins the StepLib project.
Dec 29, 1994
Norman Margolus finishes a new, fast implementation of
rendering 3D objects on the CAM8 by simulating digital light.
Dec 18, 1994
Harris L. Gilliam begins work on the StepLib C library which will provide lowlevel primatives for programming CAM8.