latestCAM8: Latest Developments

Aug 5, 2001

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:

June 12, 1995

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 UNIX sockets.

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 collecting/visualizing results.

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 is created.

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:

  1. Finite-Integer Lattice-Gas w/ 4-bits per direction, 2-body collisions and rest particle collisions.
  2. Multiphase Lattice-Gas (liquid and gas phases) w/ local LGA collisions and long-range attractive interactions.

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 /dev/fb.

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 StepLib library.

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 debugs it.

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.